spets 0.1.98 → 0.1.99

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   renderConfigJSON,
   runConfigInteractive,
   setConfigField
-} from "./chunk-HXNXQAVN.js";
+} from "./chunk-BCOGSLCX.js";
 import {
   CLIDashboardRenderer,
   DashboardClient,
@@ -12,36 +12,43 @@ import {
   generateTaskId,
   getWorkflowState,
   listTasks,
+  loadDocument,
   loadTaskMetadata,
   renderTasksJSON,
   runTasksInteractive
-} from "./chunk-NYBOEOGE.js";
+} from "./chunk-ZRWVDWBF.js";
 import {
   renderDocsJSON,
   runDocsInteractive
-} from "./chunk-3OOPOFUK.js";
+} from "./chunk-3JIHGW47.js";
 import {
   buildAvailableKnowledgeSection,
+  getKnowledgeDir,
+  listKnowledgeFiles,
   loadGuide,
+  loadKnowledgeFile,
   loadKnowledgeFiles,
   renderKnowledgeJSON,
   runKnowledgeInteractive,
   saveKnowledge
-} from "./chunk-TXGA3CZZ.js";
+} from "./chunk-3QH66XVU.js";
 import {
+  clearConfigCache,
+  getConfigPath,
   getGitHubConfig,
   getOutputsDir,
   getSpetsDir,
   getStepsDir,
+  loadAllSteps,
   loadConfig,
   spetsExists
-} from "./chunk-BQWHTHA3.js";
+} from "./chunk-2MUV3F53.js";
 
 // src/index.ts
 import { Command } from "commander";
-import { readFileSync as readFileSync18 } from "fs";
-import { dirname as dirname7, join as join14 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
+import { readFileSync as readFileSync20 } from "fs";
+import { dirname as dirname8, join as join17 } from "path";
+import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/commands/init.ts
 import { existsSync as existsSync2, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, cpSync, readFileSync } from "fs";
@@ -822,7 +829,7 @@ function formatDocStatus(status) {
 import { execSync as execSync2 } from "child_process";
 
 // src/orchestrator/index.ts
-import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, existsSync as existsSync11 } from "fs";
+import { readFileSync as readFileSync10, writeFileSync as writeFileSync5, existsSync as existsSync11, readdirSync as readdirSync2 } from "fs";
 import matter from "gray-matter";
 
 // src/orchestrator/state.ts
@@ -2167,19 +2174,31 @@ var Orchestrator = class {
     return buildCompleteResponse(this.cwd, state, "stopped");
   }
   /**
-   * Resume a stopped workflow by restoring the pre-stop phase
+   * Resume a workflow by restoring the pre-stop phase.
+   * If no taskId provided, auto-find most recent resumable task.
    */
   cmdResume(taskId) {
+    if (!taskId) {
+      const listResult = this.cmdList();
+      if (listResult.type === "list" && listResult.tasks.length > 0) {
+        taskId = listResult.tasks[0].taskId;
+      } else {
+        return buildErrorResponse("No resumable workflows found");
+      }
+    }
     const state = loadState(this.cwd, taskId);
     if (!state) {
       return buildErrorResponse(`No workflow found: ${taskId}`, taskId);
     }
+    if (state.status === "completed" || state.status === "rejected") {
+      return buildErrorResponse(`Workflow is ${state.status} and cannot be resumed`, taskId);
+    }
     if (state.status !== "stopped") {
       return this.cmdStatus(taskId);
     }
     const phaseToStatus = {
       "explore": "phase_explore",
-      "clarify": state.questions ? "clarify_pending" : "phase_clarify",
+      "clarify": state.decisions ? "clarify_pending" : "phase_clarify",
       "execute": "phase_execute",
       "verify": "phase_verify",
       "review": "approve_pending"
@@ -2192,6 +2211,37 @@ var Orchestrator = class {
     saveState(this.cwd, state);
     return this.cmdStatus(taskId);
   }
+  /**
+   * List non-terminal workflows sorted by most recently updated
+   */
+  cmdList() {
+    const outputPath = getOutputPath(this.cwd);
+    const tasks = [];
+    if (!existsSync11(outputPath)) {
+      return { type: "list", tasks: [] };
+    }
+    const dirs = readdirSync2(outputPath, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const dir of dirs) {
+      const state = loadState(this.cwd, dir.name);
+      if (!state) continue;
+      if (state.status === "completed" || state.status === "rejected") continue;
+      tasks.push({
+        taskId: state.taskId,
+        description: state.description,
+        status: state.status,
+        currentStep: state.currentStep,
+        stepIndex: state.stepIndex,
+        totalSteps: state.totalSteps,
+        updatedAt: state.updatedAt
+      });
+    }
+    tasks.sort((a, b) => {
+      const aTime = a.updatedAt ? new Date(a.updatedAt).getTime() : 0;
+      const bTime = b.updatedAt ? new Date(b.updatedAt).getTime() : 0;
+      return bTime - aTime;
+    });
+    return { type: "list", tasks };
+  }
   /**
    * Get current workflow status
    */
@@ -4190,7 +4240,7 @@ Resume with: spets resume --task ${taskId}`);
 
 // src/commands/resume.ts
 import { select as select3 } from "@inquirer/prompts";
-import { existsSync as existsSync17, readdirSync as readdirSync2, readFileSync as readFileSync16 } from "fs";
+import { existsSync as existsSync17, readdirSync as readdirSync3, readFileSync as readFileSync16 } from "fs";
 import { join as join11 } from "path";
 import { spawnSync as spawnSync3 } from "child_process";
 async function createPR(cwd, taskId, outputs) {
@@ -4224,7 +4274,7 @@ function listResumableTasks(cwd) {
     return [];
   }
   const tasks = [];
-  const taskDirs = readdirSync2(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  const taskDirs = readdirSync3(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   const orchestrator = new Orchestrator(cwd);
   for (const taskId of taskDirs) {
     const stateFile = join11(outputsDir, taskId, ".state.json");
@@ -4574,7 +4624,7 @@ function parseGitHubCommand(comment) {
 
 // src/commands/github/git-info.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync19, readdirSync as readdirSync3 } from "fs";
+import { existsSync as existsSync19, readdirSync as readdirSync4 } from "fs";
 function getGitHubInfo2(cwd) {
   const config = getGitHubConfig(cwd);
   if (config?.owner && config?.repo) {
@@ -4610,7 +4660,7 @@ function findTaskId(cwd, owner, repo, issueOrPr) {
   }
   const outputsDir = getOutputsDir(cwd);
   if (existsSync19(outputsDir)) {
-    const taskDirs = readdirSync3(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
+    const taskDirs = readdirSync4(outputsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort().reverse();
     if (taskDirs.length > 0) {
       return taskDirs[0];
     }
@@ -4620,7 +4670,7 @@ function findTaskId(cwd, owner, repo, issueOrPr) {
 
 // src/commands/github/pull-request.ts
 import { spawnSync as spawnSync4 } from "child_process";
-import { existsSync as existsSync20, readdirSync as readdirSync4, readFileSync as readFileSync17 } from "fs";
+import { existsSync as existsSync20, readdirSync as readdirSync5, readFileSync as readFileSync17 } from "fs";
 import { join as join13 } from "path";
 
 // src/commands/github/decisions.ts
@@ -4796,7 +4846,7 @@ async function createPullRequestWithAI(config, taskId, userQuery, cwd) {
   const outputsDir = join13(getOutputsDir(cwd), taskId);
   const outputs = [];
   if (existsSync20(outputsDir)) {
-    const files = readdirSync4(outputsDir).filter((f) => f.endsWith(".md"));
+    const files = readdirSync5(outputsDir).filter((f) => f.endsWith(".md"));
     for (const file of files) {
       const content = readFileSync17(join13(outputsDir, file), "utf-8");
       outputs.push({ step: file.replace(".md", ""), content });
@@ -5443,6 +5493,17 @@ async function orchestrateCommand(action, args) {
         outputJSON(result);
         break;
       }
+      case "resume": {
+        const taskId = args[0];
+        const result = orchestrator.cmdResume(taskId);
+        outputJSON(result);
+        break;
+      }
+      case "list": {
+        const result = orchestrator.cmdList();
+        outputJSON(result);
+        break;
+      }
       case "knowledge-save": {
         const taskId = args[0];
         const entriesJson = args[1];
@@ -5499,7 +5560,7 @@ async function orchestrateCommand(action, args) {
         break;
       }
       default:
-        outputError(`Unknown action: ${action}. Valid actions: init, explore-done, clarify-done, execute-done, verify-done, clarified, approve, revise, reject, stop, status, knowledge-save, knowledge-skip, knowledge-extract-done`);
+        outputError(`Unknown action: ${action}. Valid actions: init, explore-done, clarify-done, execute-done, verify-done, clarified, approve, revise, reject, stop, status, resume, list, knowledge-save, knowledge-skip, knowledge-extract-done`);
     }
   } catch (e) {
     outputError(e.message);
@@ -5674,7 +5735,7 @@ async function uiConfigCommand(action, args, options) {
     console.log(renderConfigJSON(cwd));
     return;
   }
-  const { runConfigInteractive: runConfigInteractive2 } = await import("./config-ALWYEUVJ.js");
+  const { runConfigInteractive: runConfigInteractive2 } = await import("./config-FMQ5APSF.js");
   await runConfigInteractive2(cwd);
 }
 async function uiTasksCommand(taskId, options) {
@@ -5692,7 +5753,7 @@ async function uiTasksCommand(taskId, options) {
     console.log(renderTasksJSON(taskId, cwd));
     return;
   }
-  const { runTasksInteractive: runTasksInteractive2 } = await import("./tasks-YSWQLXLI.js");
+  const { runTasksInteractive: runTasksInteractive2 } = await import("./tasks-2IAXZVDS.js");
   await runTasksInteractive2(cwd);
 }
 async function uiDocsCommand(docName, options) {
@@ -5714,7 +5775,7 @@ async function uiDocsCommand(docName, options) {
     console.log(renderDocsJSON(void 0, cwd));
     return;
   }
-  const { runDocsInteractive: runDocsInteractive2 } = await import("./docs-KUVQEWW4.js");
+  const { runDocsInteractive: runDocsInteractive2 } = await import("./docs-FNCV4EQF.js");
   await runDocsInteractive2(cwd);
 }
 async function uiKnowledgeCommand(entryName, options) {
@@ -5736,13 +5797,589 @@ async function uiKnowledgeCommand(entryName, options) {
     console.log(renderKnowledgeJSON(void 0, cwd));
     return;
   }
-  const { runKnowledgeInteractive: runKnowledgeInteractive2 } = await import("./knowledge-3WOLZUWG.js");
+  const { runKnowledgeInteractive: runKnowledgeInteractive2 } = await import("./knowledge-QC6464NS.js");
   await runKnowledgeInteractive2(cwd);
 }
 
+// src/server/index.ts
+import express from "express";
+import { createServer } from "http";
+import { join as join16, dirname as dirname7 } from "path";
+import { existsSync as existsSync23 } from "fs";
+import { fileURLToPath as fileURLToPath2 } from "url";
+
+// src/server/routes/index.ts
+import { Router as Router7 } from "express";
+
+// src/server/routes/tasks.ts
+import { Router } from "express";
+var tasksRouter = Router();
+tasksRouter.get("/", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const limit = parseInt(req.query.limit) || 20;
+    const client = new DashboardClient(cwd);
+    const data = client.listTasks({ limit });
+    res.json(data);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+tasksRouter.get("/:id", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const client = new DashboardClient(cwd);
+    const data = client.getTaskDetail(req.params.id);
+    if (!data) {
+      res.status(404).json({ error: "Task not found" });
+      return;
+    }
+    res.json(data);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+tasksRouter.get("/:id/output/:step", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const doc = loadDocument(req.params.id, req.params.step, cwd);
+    if (!doc) {
+      res.status(404).json({ error: "Output not found" });
+      return;
+    }
+    res.json(doc);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+tasksRouter.get("/:id/state", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const config = loadConfig(cwd);
+    const state = getWorkflowState(req.params.id, config, cwd);
+    if (!state) {
+      res.status(404).json({ error: "State not found" });
+      return;
+    }
+    const outputs = {};
+    state.outputs.forEach((value, key) => {
+      outputs[key] = value;
+    });
+    res.json({ ...state, outputs });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// src/server/routes/config.ts
+import { Router as Router2 } from "express";
+import { readFileSync as readFileSync18, writeFileSync as writeFileSync9 } from "fs";
+var configRouter = Router2();
+configRouter.get("/", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const config = loadConfig(cwd);
+    res.json(config);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+configRouter.get("/raw", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const configPath = getConfigPath(cwd);
+    const raw = readFileSync18(configPath, "utf-8");
+    res.json({ content: raw });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+configRouter.put("/", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { content } = req.body;
+    if (!content) {
+      res.status(400).json({ error: "content field is required" });
+      return;
+    }
+    const configPath = getConfigPath(cwd);
+    writeFileSync9(configPath, content);
+    clearConfigCache();
+    const config = loadConfig(cwd);
+    res.json(config);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// src/server/routes/steps.ts
+import { Router as Router3 } from "express";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync10, mkdirSync as mkdirSync8, rmSync as rmSync2, existsSync as existsSync21 } from "fs";
+import { join as join14 } from "path";
+var stepsRouter = Router3();
+stepsRouter.get("/", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const config = loadConfig(cwd);
+    const steps = loadAllSteps(config, cwd);
+    res.json(steps);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+stepsRouter.get("/:name/template", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const stepsDir = getStepsDir(cwd);
+    const templatePath = join14(stepsDir, req.params.name, "template.md");
+    if (!existsSync21(templatePath)) {
+      res.status(404).json({ error: "Template not found" });
+      return;
+    }
+    const content = readFileSync19(templatePath, "utf-8");
+    res.json({ name: req.params.name, content });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+stepsRouter.put("/:name/template", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { content } = req.body;
+    if (content === void 0) {
+      res.status(400).json({ error: "content field is required" });
+      return;
+    }
+    const stepsDir = getStepsDir(cwd);
+    const templatePath = join14(stepsDir, req.params.name, "template.md");
+    writeFileSync10(templatePath, content);
+    res.json({ name: req.params.name, content });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+stepsRouter.post("/", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { name, template } = req.body;
+    if (!name) {
+      res.status(400).json({ error: "name field is required" });
+      return;
+    }
+    const stepsDir = getStepsDir(cwd);
+    const stepDir = join14(stepsDir, name);
+    mkdirSync8(stepDir, { recursive: true });
+    writeFileSync10(join14(stepDir, "template.md"), template || `# ${name}
+
+Define your template here.
+`);
+    clearConfigCache();
+    const config = loadConfig(cwd);
+    if (!config.steps.includes(name)) {
+      config.steps.push(name);
+      const configPath = getConfigPath(cwd);
+      const raw = readFileSync19(configPath, "utf-8");
+      const updatedYaml = raw.replace(
+        /steps:[\s\S]*?(?=\n\w|\n$|$)/,
+        `steps:
+${config.steps.map((s) => `  - ${s}`).join("\n")}`
+      );
+      writeFileSync10(configPath, updatedYaml);
+      clearConfigCache();
+    }
+    res.json({ name, created: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+stepsRouter.delete("/:name", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const name = req.params.name;
+    const stepsDir = getStepsDir(cwd);
+    const stepDir = join14(stepsDir, name);
+    if (existsSync21(stepDir)) {
+      rmSync2(stepDir, { recursive: true });
+    }
+    clearConfigCache();
+    const config = loadConfig(cwd);
+    const updatedSteps = config.steps.filter((s) => s !== name);
+    const configPath = getConfigPath(cwd);
+    const raw = readFileSync19(configPath, "utf-8");
+    const updatedYaml = raw.replace(
+      /steps:[\s\S]*?(?=\n\w|\n$|$)/,
+      `steps:
+${updatedSteps.map((s) => `  - ${s}`).join("\n")}`
+    );
+    writeFileSync10(configPath, updatedYaml);
+    clearConfigCache();
+    res.json({ name, deleted: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+stepsRouter.put("/reorder", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { steps } = req.body;
+    if (!steps || !Array.isArray(steps)) {
+      res.status(400).json({ error: "steps array is required" });
+      return;
+    }
+    const configPath = getConfigPath(cwd);
+    const raw = readFileSync19(configPath, "utf-8");
+    const updatedYaml = raw.replace(
+      /steps:[\s\S]*?(?=\n\w|\n$|$)/,
+      `steps:
+${steps.map((s) => `  - ${s}`).join("\n")}`
+    );
+    writeFileSync10(configPath, updatedYaml);
+    clearConfigCache();
+    res.json({ steps });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// src/server/routes/knowledge.ts
+import { Router as Router4 } from "express";
+import { unlinkSync, existsSync as existsSync22 } from "fs";
+import { join as join15 } from "path";
+var knowledgeRouter = Router4();
+knowledgeRouter.get("/", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const filenames = listKnowledgeFiles(cwd);
+    const entries = filenames.map((name) => loadKnowledgeFile(name, cwd)).filter(Boolean);
+    res.json(entries);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+knowledgeRouter.get("/guide", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const guide = loadGuide(cwd);
+    res.json({ content: guide });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+knowledgeRouter.get("/:name", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const entry = loadKnowledgeFile(req.params.name, cwd);
+    if (!entry) {
+      res.status(404).json({ error: "Knowledge entry not found" });
+      return;
+    }
+    res.json(entry);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+knowledgeRouter.post("/", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { filename, content } = req.body;
+    if (!filename || !content) {
+      res.status(400).json({ error: "filename and content fields are required" });
+      return;
+    }
+    saveKnowledge(filename, content, { taskId: "web-ui", step: "manual" }, cwd);
+    const entry = loadKnowledgeFile(filename, cwd);
+    res.json(entry);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+knowledgeRouter.put("/:name", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { content } = req.body;
+    if (content === void 0) {
+      res.status(400).json({ error: "content field is required" });
+      return;
+    }
+    saveKnowledge(req.params.name, content, { taskId: "web-ui", step: "manual" }, cwd);
+    const entry = loadKnowledgeFile(req.params.name, cwd);
+    res.json(entry);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+knowledgeRouter.delete("/:name", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const knowledgeDir = getKnowledgeDir(cwd);
+    const filePath = join15(knowledgeDir, `${req.params.name}.md`);
+    if (!existsSync22(filePath)) {
+      res.status(404).json({ error: "Knowledge entry not found" });
+      return;
+    }
+    unlinkSync(filePath);
+    res.json({ name: req.params.name, deleted: true });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// src/server/routes/workflow.ts
+import { Router as Router5 } from "express";
+var workflowRouter = Router5();
+workflowRouter.post("/start", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { query } = req.body;
+    if (!query) {
+      res.status(400).json({ error: "query field is required" });
+      return;
+    }
+    const orchestrator = new Orchestrator(cwd);
+    const response = orchestrator.cmdInit(query);
+    res.json(response);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+workflowRouter.post("/:id/approve", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const orchestrator = new Orchestrator(cwd);
+    const response = orchestrator.cmdApprove(req.params.id);
+    res.json(response);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+workflowRouter.post("/:id/revise", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { feedback } = req.body;
+    if (!feedback) {
+      res.status(400).json({ error: "feedback field is required" });
+      return;
+    }
+    const orchestrator = new Orchestrator(cwd);
+    const response = orchestrator.cmdRevise(req.params.id, feedback);
+    res.json(response);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+workflowRouter.post("/:id/reject", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const orchestrator = new Orchestrator(cwd);
+    const response = orchestrator.cmdReject(req.params.id);
+    res.json(response);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+workflowRouter.post("/:id/stop", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const orchestrator = new Orchestrator(cwd);
+    const response = orchestrator.cmdStop(req.params.id);
+    res.json(response);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+workflowRouter.post("/:id/clarified", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { answers } = req.body;
+    if (!answers) {
+      res.status(400).json({ error: "answers field is required" });
+      return;
+    }
+    const orchestrator = new Orchestrator(cwd);
+    const response = orchestrator.cmdClarified(req.params.id, answers);
+    res.json(response);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+workflowRouter.get("/:id/status", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const orchestrator = new Orchestrator(cwd);
+    const response = orchestrator.cmdStatus(req.params.id);
+    res.json(response);
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+
+// src/server/routes/terminal.ts
+import { Router as Router6 } from "express";
+import { spawn as spawn8 } from "child_process";
+var sessions = /* @__PURE__ */ new Map();
+var terminalRouter = Router6();
+terminalRouter.post("/spawn", (req, res) => {
+  try {
+    const cwd = req.app.locals.cwd;
+    const { command, args } = req.body;
+    if (!command) {
+      res.status(400).json({ error: "command field is required" });
+      return;
+    }
+    const sessionId = `term-${Date.now().toString(36)}`;
+    const child = spawn8(command, args || [], {
+      cwd,
+      stdio: "pipe",
+      env: { ...process.env, FORCE_COLOR: "1" }
+    });
+    const session = { process: child, output: [] };
+    sessions.set(sessionId, session);
+    child.stdout?.on("data", (data) => {
+      session.output.push(data.toString());
+    });
+    child.stderr?.on("data", (data) => {
+      session.output.push(data.toString());
+    });
+    child.on("close", (code) => {
+      session.output.push(`
+[Process exited with code ${code}]
+`);
+    });
+    res.json({ sessionId, pid: child.pid });
+  } catch (err) {
+    res.status(500).json({ error: err.message });
+  }
+});
+terminalRouter.get("/:sessionId", (req, res) => {
+  const session = sessions.get(req.params.sessionId);
+  if (!session) {
+    res.status(404).json({ error: "Session not found" });
+    return;
+  }
+  const output = session.output.splice(0);
+  const alive = !session.process.killed && session.process.exitCode === null;
+  res.json({ output, alive });
+});
+terminalRouter.post("/:sessionId/input", (req, res) => {
+  const session = sessions.get(req.params.sessionId);
+  if (!session) {
+    res.status(404).json({ error: "Session not found" });
+    return;
+  }
+  const { input: input2 } = req.body;
+  if (session.process.stdin?.writable) {
+    session.process.stdin.write(input2);
+  }
+  res.json({ ok: true });
+});
+terminalRouter.delete("/:sessionId", (req, res) => {
+  const session = sessions.get(req.params.sessionId);
+  if (!session) {
+    res.status(404).json({ error: "Session not found" });
+    return;
+  }
+  session.process.kill();
+  sessions.delete(req.params.sessionId);
+  res.json({ killed: true });
+});
+
+// src/server/routes/index.ts
+var apiRouter = Router7();
+apiRouter.use("/tasks", tasksRouter);
+apiRouter.use("/config", configRouter);
+apiRouter.use("/steps", stepsRouter);
+apiRouter.use("/knowledge", knowledgeRouter);
+apiRouter.use("/workflow", workflowRouter);
+apiRouter.use("/terminal", terminalRouter);
+
+// src/server/ws/index.ts
+import { WebSocketServer, WebSocket } from "ws";
+function setupWebSocket(server) {
+  const wss = new WebSocketServer({ server, path: "/ws" });
+  wss.on("connection", (ws) => {
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        handleMessage(ws, msg);
+      } catch {
+      }
+    });
+  });
+  function broadcast(type, data) {
+    const message = JSON.stringify({ type, data });
+    wss.clients.forEach((client) => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(message);
+      }
+    });
+  }
+  function handleMessage(_ws, _msg) {
+  }
+  return { wss, broadcast };
+}
+
+// src/server/index.ts
+function startServer(options) {
+  const { cwd, port } = options;
+  const app = express();
+  app.locals.cwd = cwd;
+  app.use(express.json());
+  app.use("/api", apiRouter);
+  const __dirname3 = dirname7(fileURLToPath2(import.meta.url));
+  const webDistPath = join16(__dirname3, "..", "web", "dist");
+  const webDistDevPath = join16(__dirname3, "..", "..", "web", "dist");
+  const staticPath = existsSync23(webDistPath) ? webDistPath : webDistDevPath;
+  if (existsSync23(staticPath)) {
+    app.use(express.static(staticPath));
+    app.get("*", (_req, res) => {
+      res.sendFile(join16(staticPath, "index.html"));
+    });
+  } else {
+    app.get("*", (_req, res) => {
+      res.status(200).send(
+        '<html><body style="font-family:system-ui;display:flex;align-items:center;justify-content:center;height:100vh;margin:0"><div style="text-align:center"><h1>spets</h1><p>Web UI not built yet. Run <code>npm run build:web</code> first.</p></div></body></html>'
+      );
+    });
+  }
+  app.use((err, _req, res, _next) => {
+    console.error("Server error:", err.message);
+    res.status(500).json({ error: err.message });
+  });
+  const server = createServer(app);
+  setupWebSocket(server);
+  server.listen(port, () => {
+    console.log(`
+  spets web UI running at http://localhost:${port}
+`);
+  });
+  return server;
+}
+
+// src/commands/web.ts
+async function webCommand(options) {
+  const cwd = process.cwd();
+  if (!spetsExists(cwd)) {
+    console.error("Error: spets not initialized in this directory.\nRun `spets init` first.");
+    process.exit(1);
+  }
+  const port = parseInt(options.port, 10);
+  if (isNaN(port)) {
+    console.error("Error: Invalid port number");
+    process.exit(1);
+  }
+  startServer({ cwd, port });
+  if (options.open) {
+    try {
+      const open = await import("open");
+      await open.default(`http://localhost:${port}`);
+    } catch {
+    }
+  }
+}
+
 // src/index.ts
-var __dirname2 = dirname7(fileURLToPath2(import.meta.url));
-var pkg = JSON.parse(readFileSync18(join14(__dirname2, "..", "package.json"), "utf-8"));
+var __dirname2 = dirname8(fileURLToPath3(import.meta.url));
+var pkg = JSON.parse(readFileSync20(join17(__dirname2, "..", "package.json"), "utf-8"));
 var program = new Command();
 program.name("spets").description("Spec Driven Development Execution Framework").version(pkg.version).addHelpText("after", `
 Examples:
@@ -5767,6 +6404,7 @@ program.command("github").description("Handle GitHub Action callback (internal)"
 program.command("plugin").description("Manage plugins").argument("<action>", "Action: install, uninstall, list").argument("[name]", "Plugin name").action(pluginCommand);
 program.command("dashboard").description("Interactive task dashboard with drill-down").option("-t, --task <taskId>", "Show details for specific task").option("--json", "Output as JSON (for external consumers)").option("-l, --limit <number>", "Limit number of tasks shown", "20").action(dashboardCommand);
 program.command("orchestrate").description("Workflow orchestration (JSON API for Claude Code)").argument("<action>", "Action: init, done, clarified, approve, revise, reject, stop, status").argument("[args...]", "Action arguments").action(orchestrateCommand);
+program.command("web").description("Launch web UI for managing spets").option("-p, --port <port>", "Port number", "4777").option("--open", "Open browser automatically").action(webCommand);
 var ui = program.command("ui").description("Interactive TUI hub for managing spets").option("--json", "Output as JSON (for coding agents)").action(uiCommand);
 ui.command("config").description("View and edit configuration").argument("[action]", "Action: set").argument("[args...]", "Action arguments (field, value)").option("--json", "Output as JSON").option("--edit", "Open config in editor").action(uiConfigCommand);
 ui.command("tasks").description("Browse workflow tasks").argument("[taskId]", "Task ID for details").option("--json", "Output as JSON").action(uiTasksCommand);