npm - @splinterzzz/ouro - Versions diffs - 0.1.2 → 0.1.4 - Mend

@splinterzzz/ouro 0.1.2 → 0.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dashboard-dist/assets/index-Btdawh-I.js +64 -0
package/dashboard-dist/index.html +1 -1
package/package.json +1 -1
package/src/lib/agents.js +19 -12
package/src/lib/claudeCodeExec.js +7 -1
package/src/lib/config.js +9 -0
package/src/lib/daemon.js +16 -1
package/src/lib/preview.js +40 -6
package/src/server/index.js +127 -74
package/dashboard-dist/assets/index-B-lZ4RcX.js +0 -64

package/dashboard-dist/index.html CHANGED Viewed

@@ -9,7 +9,7 @@
          flash white around a near-black app on load. -->
     <meta name="theme-color" content="#0b0a12" />
     <title>ouro</title>
-    <script type="module" crossorigin src="/assets/index-B-lZ4RcX.js"></script>
+    <script type="module" crossorigin src="/assets/index-Btdawh-I.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-C21ZXjPS.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@splinterzzz/ouro",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Loop engineering CLI: repo-rooted kanban + agent loop, powered by Claude Code / Codex headless mode (no API key required).",
   "type": "module",
   "keywords": [

package/src/lib/agents.js CHANGED Viewed

@@ -187,16 +187,22 @@ const SEEDS = [
       name: "Senior Engineer",
       glyph: "◆",
       description: "Ships production changes with minimal, well-tested diffs.",
-      model: DEFAULT_MODEL,
-      tools: ["Read", "Grep", "Glob", "Edit", "Write", "Bash"],
+      model: "opus",
+      tools: ["Read", "Grep", "Glob", "Edit", "Write", "Bash", "*"],
     },
-    body: `You are a senior engineer working in an isolated git worktree.
+    body: `You are a senior engineer working in an isolated git worktree, and you orchestrate — you do not do every edit yourself.
+Orchestration, before you touch anything:
+1. Break the ticket into subtasks. Independent ones (separate components, unrelated modules — nothing that shares state or a file with anything else in flight) are delegation candidates; anything ambiguous, architectural, or touching shared state is yours to do directly.
+2. Dispatch each independent subtask to a Task subagent rather than editing it yourself. If the Task tool exposes a model choice, request sonnet or haiku for these — applying a known, scoped change to one file is mechanical execution, not a judgment call, and doesn't need your tier. If it doesn't expose model choice, dispatch anyway — the parallelism is the primary win, the cost saving is secondary.
+3. Do the judgment work yourself: resolving the ticket's ambiguity, anything touching shared state, and the final integration once subagents land.
+4. Keep verification (typecheck/lint/tests) serial, after every subagent lands — never per-subtask, and never delegated.
 Work to these standards:
-- Read the surrounding code before you edit it. Match its idiom, naming, and comment density.
+- Read the surrounding code before you edit it (yourself, or brief a subagent to). Match its idiom, naming, and comment density.
 - Prefer the smallest diff that fully solves the ticket. No drive-by refactors.
 - Never delete or weaken a test to make something pass.
-- Run the relevant tests before you call the work done, and report what you ran.
+- Verify with the fastest check that actually proves correctness: typecheck + lint first. Only run a full production build if the ticket specifically needs to validate build output — tsc and lint already catch what a build would, slower.
 - If the ticket is ambiguous, state the assumption you made in your final message rather than guessing silently.`,
   },
   {
@@ -205,17 +211,18 @@ Work to these standards:
       name: "Bug Fixer",
       glyph: "▲",
       description: "Reproduces first, then fixes the root cause — not the symptom.",
-      model: DEFAULT_MODEL,
-      tools: ["Read", "Grep", "Glob", "Edit", "Write", "Bash"],
+      model: "opus",
+      tools: ["Read", "Grep", "Glob", "Edit", "Write", "Bash", "*"],
     },
-    body: `You are a debugging specialist working in an isolated git worktree.
+    body: `You are a debugging specialist working in an isolated git worktree, and you orchestrate — evidence-gathering delegates, diagnosis doesn't.
 Method, in order:
 1. Reproduce the bug and state the exact failing behaviour you observed.
-2. Find the root cause. Trace it — do not pattern-match a plausible-looking fix.
-3. Fix the cause, not the symptom. If the real fix is out of scope, say so explicitly.
-4. Add or extend a test that fails before your change and passes after it.
-5. Report the reproduction, the cause, and the fix separately in your final message.`,
+2. Find the root cause. Trace it — do not pattern-match a plausible-looking fix. If more than one cause is plausible, dispatch a Task subagent per hypothesis to gather evidence for or against it in parallel, rather than chasing them one at a time. If the Task tool exposes a model choice, request sonnet or haiku for these — each is a bounded, scoped investigation, not the diagnosis itself.
+3. Weigh the evidence and decide the real cause yourself — a subagent reports what it found, it does not get to conclude the diagnosis.
+4. Fix the cause, not the symptom. If the real fix is out of scope, say so explicitly.
+5. Add or extend a test that fails before your change and passes after it.
+6. Report the reproduction, the cause, and the fix separately in your final message.`,
   },
   {
     id: "reviewer",

package/src/lib/claudeCodeExec.js CHANGED Viewed

@@ -34,10 +34,16 @@ function agentFlags(agent, restrictTo) {
   }
   const granted = agent.tools?.length ? agent.tools : DEFAULT_WRITE_TOOLS;
+  // "*" means fully unrestricted — every native Claude Code tool (including
+  // Task, for subagent fan-out) plus any project skills and connected
+  // MCP/plugin tools, none of which ouro's fixed TOOL_UNIVERSE enumerates.
+  // Only honored outside a read-only phase — Analyze/Plan/QA must never
+  // widen past restrictTo no matter what the agent itself requests.
+  const unrestricted = granted.includes("*") && !restrictTo;
   const allowed = restrictTo ? granted.filter((t) => restrictTo.includes(t)) : granted;
   const flags = [];
-  if (allowed.length) flags.push("--allowedTools", allowed.join(","));
+  if (!unrestricted && allowed.length) flags.push("--allowedTools", allowed.join(","));
   if (agent.model) flags.push("--model", agent.model);
   // Append rather than replace: Claude Code's own system prompt carries the
   // tool contract, so blowing it away with --system-prompt breaks tool use.

package/src/lib/config.js CHANGED Viewed

@@ -16,6 +16,10 @@ const DEFAULTS = {
   // explicit "Create PR" button instead — pushing is outward-facing, so this
   // is deliberately a knob and not a hardcode.
   autoShip: true,
+  // Ceiling on agent-loop QA loop-back re-runs (enterStaging) before the ticket
+  // escalates to a human — a safety valve against a runaway loop that keeps
+  // failing QA and re-running the (expensive) engineer forever.
+  maxQaAttempts: 3,
   telegram: {
     botTokenEnvVar: "OURO_TELEGRAM_BOT_TOKEN",
     chatIdEnvVar: "OURO_TELEGRAM_CHAT_ID",
@@ -94,6 +98,11 @@ export function getAutoShip() {
   return readConfig().autoShip !== false;
 }
+export function getMaxQaAttempts() {
+  const n = readConfig().maxQaAttempts;
+  return Number.isInteger(n) && n >= 1 ? n : 3;
+}
 /** Staging config, each field null when unset (ouro then resolves it per-repo). */
 export function getStaging() {
   const s = readConfig().staging ?? {};

package/src/lib/daemon.js CHANGED Viewed

@@ -60,9 +60,24 @@ export function updateRecord(name, patch) {
   return next;
 }
-/** Signal 0 probes for existence without delivering anything. */
+/**
+ * Signal 0 probes for existence without delivering anything. On win32 this is
+ * unreliable on its own: PIDs recycle fast, and once our dead pid is reused by
+ * an unrelated process owned by another user/session, `process.kill(pid, 0)`
+ * throws EPERM (exists, just not ours) — indistinguishable from our own
+ * still-alive service. That false positive pins a stale pid file forever
+ * (`stop` reports "refused to die" against a ghost). Cross-check with
+ * `tasklist` so a recycled pid isn't mistaken for our service.
+ */
 export function isAlive(pid) {
   if (!pid) return false;
+  if (process.platform === "win32") {
+    const result = spawnSync("tasklist", ["/FI", `PID eq ${pid}`, "/FO", "CSV", "/NH"], {
+      encoding: "utf-8",
+    });
+    const out = result.stdout || "";
+    return out.includes(`"${pid}"`);
+  }
   try {
     process.kill(pid, 0);
     return true;

package/src/lib/preview.js CHANGED Viewed

@@ -73,15 +73,41 @@ function waitForPort(port, timeoutMs = 15000) {
   });
 }
+// Most dev servers (Next, Vite, CRA, ...) print the URL they actually bound
+// once they're up — which can differ from the guessed port if it was taken
+// (Next silently increments to the next free one). Sniffing stdout for that
+// line is the only way to know the real port rather than trusting the guess.
+const URL_IN_OUTPUT = /https?:\/\/(?:localhost|127\.0\.0\.1|0\.0\.0\.0)(?::(\d+))?/i;
+function sniffUrl(proc, timeoutMs) {
+  return new Promise((resolve) => {
+    let done = false;
+    const finish = (url) => {
+      if (done) return;
+      done = true;
+      proc.stdout?.off("data", onData);
+      resolve(url);
+    };
+    const onData = (chunk) => {
+      const match = URL_IN_OUTPUT.exec(chunk.toString());
+      if (match) finish(match[0].replace("0.0.0.0", "localhost"));
+    };
+    proc.stdout?.on("data", onData);
+    setTimeout(() => finish(null), timeoutMs);
+  });
+}
 /**
  * Start (or restart) the preview for a ticket. Returns a status object; never
  * throws. `started:false` means nothing resolved — the card shows "no preview"
- * and the stage goes on.
+ * and the stage goes on. `reachable:false` means it launched but never came up
+ * (or came up on a port that never got confirmed) — callers must not surface
+ * `url` to the UI in that case, it points at nothing trustworthy.
  */
 export async function startPreview(ticketId, { cwd, signal } = {}) {
   stopPreview(ticketId); // never two for one ticket
-  const { command, port, source } = await resolvePreview({ cwd, signal });
+  const { command, port: guessedPort, source } = await resolvePreview({ cwd, signal });
   if (!command) return { started: false, reason: "no preview command resolved", source };
   let proc;
@@ -91,13 +117,21 @@ export async function startPreview(ticketId, { cwd, signal } = {}) {
     return { started: false, reason: `spawn failed: ${err.message || err}`, source };
   }
   proc.on("error", () => {}); // a preview that fails to launch must not crash the stage
-  proc.stdout?.on("data", () => {});
   proc.stderr?.on("data", () => {});
-  const url = port ? `http://localhost:${port}` : null;
-  previews.set(ticketId, { proc, url, command, port });
+  const timeoutMs = 15000;
+  const [sniffed, portOpen] = await Promise.all([
+    sniffUrl(proc, timeoutMs),
+    guessedPort ? waitForPort(guessedPort, timeoutMs) : Promise.resolve(false),
+  ]);
+  // stdout gave us the real bound URL — trust it over the pre-spawn guess,
+  // since that's the only way to catch Next.js et al. auto-incrementing off
+  // an already-occupied port.
+  const url = sniffed ?? (portOpen ? `http://localhost:${guessedPort}` : null);
+  const port = sniffed ? Number(URL_IN_OUTPUT.exec(sniffed)?.[1] ?? guessedPort) : guessedPort;
+  const reachable = Boolean(sniffed) || portOpen;
-  const reachable = port ? await waitForPort(port) : false;
+  previews.set(ticketId, { proc, url, command, port });
   return { started: true, url, command, port, source, reachable };
 }

package/src/server/index.js CHANGED Viewed

@@ -9,8 +9,8 @@ import { createTicketWorktree, diffWorktree } from "../lib/worktree.js";
 import { contextManifest, listContextFiles, listReferencedFiles } from "../lib/artifacts.js";
 import { appendRunLog, readRunLog } from "../lib/ouroLog.js";
 import { runTests } from "../lib/staging.js";
-import { startPreview, stopPreview, previewInfo, stopAllPreviews } from "../lib/preview.js";
-import { readConfig, writeConfig, getDefaultMode, setDefaultMode, getAutoShip, telegramTokenVar } from "../lib/config.js";
+import { startPreview, stopPreview, previewInfo } from "../lib/preview.js";
+import { readConfig, writeConfig, getDefaultMode, setDefaultMode, getAutoShip, getMaxQaAttempts, telegramTokenVar } from "../lib/config.js";
 import { readEnvVars, writeEnvVars } from "../lib/env.js";
 import { looksLikeToken, maskToken, verifyBotToken } from "../lib/telegram.js";
 import { startService, stopService, serviceStatus, isAlive, tailLog, uptime } from "../lib/daemon.js";
@@ -289,9 +289,17 @@ export function createServer() {
     // Preview once, reused across QA attempts; torn down when the ticket leaves.
     const previewStatus = await startPreview(ticketId, { cwd: base.worktree, signal }).catch(() => null);
+    // Only surface a URL once it's confirmed reachable — an unreachable one
+    // (or a guessed port that was never actually confirmed) is worse than no
+    // link, since it silently points at nothing or, worse, someone else's
+    // server that happened to already be on that port.
     store.update(ticketId, {
-      previewUrl: previewStatus?.url ?? null,
-      previewNote: previewStatus?.started ? null : "no preview configured",
+      previewUrl: previewStatus?.reachable ? previewStatus.url : null,
+      previewNote: !previewStatus?.started
+        ? "no preview configured"
+        : previewStatus.reachable
+          ? null
+          : "preview didn't come up in time",
     });
     while (!signal.aborted) {
@@ -331,9 +339,10 @@ export function createServer() {
         appendRunLog(store.get(ticketId), shipOutcome(shipResult));
         return;
       }
-      // Not ready. Loop-stop guard: a 2nd failure escalates to a human,
-      // regardless of mode — don't loop forever.
-      if (attempt >= 2) {
+      // Not ready. Loop-stop guard: once we hit the configurable ceiling
+      // (maxQaAttempts) the ticket escalates to a human, regardless of mode —
+      // don't loop forever re-running the expensive engineer.
+      if (attempt >= getMaxQaAttempts()) {
         store.update(ticketId, { awaitingQa: true, escalated: true });
         appendRunLog(store.get(ticketId), `QA failed ${attempt}× — escalated to human`);
         return;
@@ -353,36 +362,29 @@ export function createServer() {
     }
   }
-  // --- tickets ---
-  app.get("/api/tickets", (_req, res) => {
-    res.json(store.list());
-  });
-  app.post("/api/tickets", (req, res) => {
-    const { title, body, source, agentId, mode, priority, summary } = req.body;
-    if (!title?.trim()) return res.status(400).json({ error: "title is required" });
-    res.json(store.create({ title: title.trim(), body: body ?? "", source, agentId, mode, priority, summary }));
-  });
-  app.post("/api/tickets/:id/analyze", async (req, res) => {
-    const ticket = store.get(req.params.id);
-    if (!ticket) return res.status(404).json({ error: "not found" });
-    if (runs.isRunning(ticket.id)) return res.status(409).json({ error: "already running" });
+  /**
+   * The read-only Analyst pass, factored out of its route so the auto-pipeline
+   * can chain it into a run without a second HTTP hop. Owns its own run
+   * registration and the transient `analyzing` flag, and returns `{ ok }` so a
+   * caller can decide whether to proceed — abort or a caught error is `ok:false`
+   * (the error is still logged to the ticket, as when a human clicked Analyze).
+   */
+  async function runAnalyze(ticketId) {
+    const ticket = store.get(ticketId);
+    if (!ticket || runs.isRunning(ticketId)) return { ok: false };
     let signal;
     try {
-      signal = runs.begin(ticket.id, "analyze");
-    } catch (err) {
-      return res.status(409).json({ error: String(err.message || err) });
+      signal = runs.begin(ticketId, "analyze");
+    } catch {
+      return { ok: false };
     }
-    res.json({ started: true });
     // Analyze is read-only and leaves the ticket where it is; a transient flag
     // drives the card's "Analyzing…" state without faking a worktree run.
-    store.update(ticket.id, { analyzing: true });
+    store.update(ticketId, { analyzing: true });
-    const onEvent = (event) => store.appendLog(ticket.id, { type: "agent_event", event });
+    const onEvent = (event) => store.appendLog(ticketId, { type: "agent_event", event });
     try {
       // Always the Analyst agent for this step, regardless of the ticket's
@@ -398,8 +400,8 @@ export function createServer() {
         onEvent,
         agent: analyst,
       });
-      if (signal.aborted) return; // cancelled mid-analysis — /cancel already reconciled it
-      store.update(ticket.id, {
+      if (signal.aborted) return { ok: false }; // cancelled mid-analysis — /cancel already reconciled it
+      store.update(ticketId, {
         status: "analyzed",
         analyzing: false,
         summary: result.summary,
@@ -407,51 +409,39 @@ export function createServer() {
         filesLikelyAffected: Array.isArray(result.files_likely_affected) ? result.files_likely_affected : [],
         acceptanceCriteria: Array.isArray(result.acceptance_criteria) ? result.acceptance_criteria : [],
       });
+      return { ok: true };
     } catch (err) {
-      store.update(ticket.id, { analyzing: false });
-      store.appendLog(ticket.id, { type: "error", text: String(err.message || err) });
+      store.update(ticketId, { analyzing: false });
+      store.appendLog(ticketId, { type: "error", text: String(err.message || err) });
+      return { ok: false };
     } finally {
-      runs.end(ticket.id);
-    }
-  });
-  app.post("/api/tickets/:id/mode", (req, res) => {
-    const { mode } = req.body; // "agent" | "human" | null (inherit board default)
-    if (mode !== null && mode !== "agent" && mode !== "human") {
-      return res.status(400).json({ error: "mode must be 'agent', 'human', or null" });
+      runs.end(ticketId);
     }
-    const ticket = store.update(req.params.id, { mode });
-    if (!ticket) return res.status(404).json({ error: "not found" });
-    res.json(ticket);
-  });
-  app.post("/api/tickets/:id/agent", (req, res) => {
-    const { agentId } = req.body;
-    if (agentId && !getAgent(agentId)) return res.status(400).json({ error: `no such agent: ${agentId}` });
-    const ticket = store.update(req.params.id, { agentId: agentId ?? null });
-    if (!ticket) return res.status(404).json({ error: "not found" });
-    res.json(ticket);
-  });
+  }
-  app.post("/api/tickets/:id/run", async (req, res) => {
-    const ticket = store.get(req.params.id);
-    if (!ticket) return res.status(404).json({ error: "not found" });
-    if (runs.isRunning(ticket.id)) return res.status(409).json({ error: "already running" });
+  /**
+   * The implementation run, factored out of its route for the same reason. Owns
+   * its own run registration, resolves mode/agent, resets the staging state to a
+   * clean QA budget, cuts the worktree, then either runs the agent straight into
+   * Staging (agent mode) or plans and waits for approval (human mode).
+   */
+  async function runImplementation(ticketId) {
+    const ticket = store.get(ticketId);
+    if (!ticket || runs.isRunning(ticketId)) return;
     const mode = resolveMode(ticket);
     const agent = resolveAgent(ticket);
     let signal;
     try {
-      signal = runs.begin(ticket.id, mode);
-    } catch (err) {
-      return res.status(409).json({ error: String(err.message || err) });
+      signal = runs.begin(ticketId, mode);
+    } catch {
+      return;
     }
-    res.json({ started: true, mode, agentId: agent?.id ?? null });
     // A fresh run resets the staging state so a re-run starts with a clean QA
     // budget (the loop-stop guard counts from here).
-    store.update(ticket.id, {
+    store.update(ticketId, {
       status: "in_progress",
       mode,
       agentId: agent?.id ?? ticket.agentId,
@@ -463,11 +453,11 @@ export function createServer() {
       escalated: false,
     });
-    const onEvent = (event) => store.appendLog(ticket.id, { type: "agent_event", event });
+    const onEvent = (event) => store.appendLog(ticketId, { type: "agent_event", event });
     try {
-      const { dir: worktreeDir, branch, base } = await createTicketWorktree(ticket.id);
-      store.update(ticket.id, { worktree: worktreeDir, branch, baseBranch: base });
+      const { dir: worktreeDir, branch, base } = await createTicketWorktree(ticketId);
+      store.update(ticketId, { worktree: worktreeDir, branch, baseBranch: base });
       const prompt = buildImplementationPrompt(ticket);
@@ -475,17 +465,17 @@ export function createServer() {
         // Full autonomy, single call.
         const result = await runAgent({ prompt, cwd: worktreeDir, onEvent, signal, agent });
         if (result.aborted) return; // cancel route already marked it
-        const diff = await diffWorktree(ticket.id).catch(() => null);
-        store.update(ticket.id, { status: "staging", diff, sessionId: result.sessionId, awaitingApproval: false });
+        const diff = await diffWorktree(ticketId).catch(() => null);
+        store.update(ticketId, { status: "staging", diff, sessionId: result.sessionId, awaitingApproval: false });
         // Validate in Staging before anything ships — the QA gate stands between
         // a finished run and the PR.
-        await enterStaging(ticket.id, { signal, onEvent, mode });
+        await enterStaging(ticketId, { signal, onEvent, mode });
       } else {
         // Human-in-the-loop: plan only, no writes yet. The card shows the
         // plan and waits for an explicit Approve before phase 2 runs.
         const result = await planTicket({ prompt, cwd: worktreeDir, onEvent, signal, agent });
         if (result.aborted) return;
-        store.update(ticket.id, {
+        store.update(ticketId, {
           status: "staging",
           sessionId: result.sessionId,
           plan: result.lastMessage,
@@ -493,14 +483,77 @@ export function createServer() {
         });
       }
     } catch (err) {
-      store.appendLog(ticket.id, { type: "error", text: String(err.message || err) });
-      store.cancel(ticket.id, `Run failed: ${err.message || err}`);
-      appendRunLog(store.get(ticket.id), `failed: ${String(err.message || err).split("\n")[0].slice(0, 60)}`);
+      store.appendLog(ticketId, { type: "error", text: String(err.message || err) });
+      store.cancel(ticketId, `Run failed: ${err.message || err}`);
+      appendRunLog(store.get(ticketId), `failed: ${String(err.message || err).split("\n")[0].slice(0, 60)}`);
     } finally {
-      runs.end(ticket.id);
+      runs.end(ticketId);
+    }
+  }
+  // Agent loop is hands-off from intake onward: a freshly created agent-mode
+  // ticket analyzes then runs on its own — the Telegram interview is the only
+  // human touch until the PR. A failed/cancelled analyze leaves it in Inbox
+  // rather than running blind. Human mode leaves it in Inbox for the buttons.
+  async function autoPipeline(ticketId) {
+    const analysis = await runAnalyze(ticketId);
+    if (!analysis?.ok) return;
+    if (store.get(ticketId)?.status !== "analyzed") return;
+    await runImplementation(ticketId);
+  }
+  // --- tickets ---
+  app.get("/api/tickets", (_req, res) => {
+    res.json(store.list());
+  });
+  app.post("/api/tickets", (req, res) => {
+    const { title, body, source, agentId, mode, priority, summary } = req.body;
+    if (!title?.trim()) return res.status(400).json({ error: "title is required" });
+    const ticket = store.create({ title: title.trim(), body: body ?? "", source, agentId, mode, priority, summary });
+    res.json(ticket);
+    if (resolveMode(ticket) === "agent") {
+      autoPipeline(ticket.id).catch((err) => store.appendLog(ticket.id, { type: "error", text: `auto-pipeline: ${String(err.message || err)}` }));
     }
   });
+  app.post("/api/tickets/:id/analyze", (req, res) => {
+    const ticket = store.get(req.params.id);
+    if (!ticket) return res.status(404).json({ error: "not found" });
+    if (runs.isRunning(ticket.id)) return res.status(409).json({ error: "already running" });
+    res.json({ started: true });
+    runAnalyze(ticket.id).catch((err) => store.appendLog(ticket.id, { type: "error", text: String(err.message || err) }));
+  });
+  app.post("/api/tickets/:id/mode", (req, res) => {
+    const { mode } = req.body; // "agent" | "human" | null (inherit board default)
+    if (mode !== null && mode !== "agent" && mode !== "human") {
+      return res.status(400).json({ error: "mode must be 'agent', 'human', or null" });
+    }
+    const ticket = store.update(req.params.id, { mode });
+    if (!ticket) return res.status(404).json({ error: "not found" });
+    res.json(ticket);
+  });
+  app.post("/api/tickets/:id/agent", (req, res) => {
+    const { agentId } = req.body;
+    if (agentId && !getAgent(agentId)) return res.status(400).json({ error: `no such agent: ${agentId}` });
+    const ticket = store.update(req.params.id, { agentId: agentId ?? null });
+    if (!ticket) return res.status(404).json({ error: "not found" });
+    res.json(ticket);
+  });
+  app.post("/api/tickets/:id/run", (req, res) => {
+    const ticket = store.get(req.params.id);
+    if (!ticket) return res.status(404).json({ error: "not found" });
+    if (runs.isRunning(ticket.id)) return res.status(409).json({ error: "already running" });
+    const mode = resolveMode(ticket);
+    const agent = resolveAgent(ticket);
+    res.json({ started: true, mode, agentId: agent?.id ?? null });
+    runImplementation(ticket.id).catch((err) => store.appendLog(ticket.id, { type: "error", text: String(err.message || err) }));
+  });
   app.post("/api/tickets/:id/approve", async (req, res) => {
     const ticket = store.get(req.params.id);
     if (!ticket) return res.status(404).json({ error: "not found" });
@@ -685,7 +738,7 @@ export function createServer() {
     // ouro already holding the port. Without it, a probe that gets a 200 only
     // proves someone is listening — not that the process we just spawned is
     // the one answering.
-    res.json({ backend: getBackendName(), defaultMode: getDefaultMode(), autoShip: getAutoShip(), pid: process.pid, config });
+    res.json({ backend: getBackendName(), defaultMode: getDefaultMode(), autoShip: getAutoShip(), maxQaAttempts: getMaxQaAttempts(), pid: process.pid, config });
   });
   app.post("/api/config/backend", (req, res) => {