@harness-engineering/orchestrator 0.2.0

package/dist/index.mjs

@@ -0,0 +1,1330 @@
+// src/core/retry.ts
+var CONTINUATION_DELAY_MS = 1e3;
+var BASE_FAILURE_DELAY_MS = 1e4;
+var DEFAULT_MAX_RETRY_BACKOFF_MS = 3e5;
+function calculateRetryDelay(attempt, type, maxRetryBackoffMs = DEFAULT_MAX_RETRY_BACKOFF_MS) {
+  if (type === "continuation") {
+    return CONTINUATION_DELAY_MS;
+  }
+  const delay = BASE_FAILURE_DELAY_MS * Math.pow(2, attempt - 1);
+  return Math.min(delay, maxRetryBackoffMs);
+}
+
+// src/core/candidate-selection.ts
+function sortCandidates(issues) {
+  return [...issues].sort((a, b) => {
+    const pa = a.priority ?? Number.MAX_SAFE_INTEGER;
+    const pb = b.priority ?? Number.MAX_SAFE_INTEGER;
+    if (pa !== pb) return pa - pb;
+    const ca = a.createdAt ?? "\uFFFF";
+    const cb = b.createdAt ?? "\uFFFF";
+    if (ca !== cb) return ca < cb ? -1 : 1;
+    return a.identifier.localeCompare(b.identifier);
+  });
+}
+function isEligible(issue, state, activeStates, terminalStates) {
+  if (!issue.id || !issue.identifier || !issue.title || !issue.state) {
+    return false;
+  }
+  const normalizedState = issue.state.toLowerCase();
+  const normalizedActive = activeStates.map((s) => s.toLowerCase());
+  const normalizedTerminal = terminalStates.map((s) => s.toLowerCase());
+  if (!normalizedActive.includes(normalizedState)) {
+    return false;
+  }
+  if (normalizedTerminal.includes(normalizedState)) {
+    return false;
+  }
+  if (state.claimed.has(issue.id)) {
+    return false;
+  }
+  if (state.running.has(issue.id)) {
+    return false;
+  }
+  if (normalizedState === "todo" && issue.blockedBy.length > 0) {
+    const hasNonTerminalBlocker = issue.blockedBy.some((blocker) => {
+      if (blocker.state === null) return true;
+      return !normalizedTerminal.includes(blocker.state.toLowerCase());
+    });
+    if (hasNonTerminalBlocker) {
+      return false;
+    }
+  }
+  return true;
+}
+function selectCandidates(issues, state, activeStates, terminalStates) {
+  const sorted = sortCandidates(issues);
+  return sorted.filter((issue) => isEligible(issue, state, activeStates, terminalStates));
+}
+
+// src/core/concurrency.ts
+function getAvailableSlots(state) {
+  return Math.max(state.maxConcurrentAgents - state.running.size, 0);
+}
+function getPerStateCount(running) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const entry of running.values()) {
+    const key = entry.issue.state.toLowerCase();
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  return counts;
+}
+function canDispatch(state, issueState, maxConcurrentAgentsByState) {
+  if (getAvailableSlots(state) <= 0) {
+    return false;
+  }
+  const normalizedState = issueState.toLowerCase();
+  const perStateCap = maxConcurrentAgentsByState[normalizedState];
+  if (perStateCap !== void 0) {
+    const perStateCounts = getPerStateCount(state.running);
+    const currentCount = perStateCounts.get(normalizedState) ?? 0;
+    if (currentCount >= perStateCap) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/core/reconciliation.ts
+function reconcile(state, runningStates, activeStates, terminalStates) {
+  const effects = [];
+  const normalizedActive = activeStates.map((s) => s.toLowerCase());
+  const normalizedTerminal = terminalStates.map((s) => s.toLowerCase());
+  for (const [issueId, entry] of state.running) {
+    const currentIssue = runningStates.get(issueId);
+    if (!currentIssue) {
+      continue;
+    }
+    const normalizedState = currentIssue.state.toLowerCase();
+    if (normalizedTerminal.includes(normalizedState)) {
+      effects.push({ type: "stop", issueId, reason: `terminal_state: ${normalizedState}` });
+      effects.push({ type: "cleanWorkspace", issueId, identifier: entry.identifier });
+      effects.push({ type: "releaseClaim", issueId });
+    } else if (!normalizedActive.includes(normalizedState)) {
+      effects.push({ type: "stop", issueId, reason: `non_active_state: ${normalizedState}` });
+      effects.push({ type: "releaseClaim", issueId });
+    }
+  }
+  return effects;
+}
+
+// src/core/state-machine.ts
+function cloneState(state) {
+  return {
+    ...state,
+    running: new Map(state.running),
+    claimed: new Set(state.claimed),
+    retryAttempts: new Map(state.retryAttempts),
+    completed: new Set(state.completed),
+    tokenTotals: { ...state.tokenTotals },
+    rateLimits: { ...state.rateLimits }
+  };
+}
+function handleTick(state, candidates, runningStates, config, nowMs) {
+  const next = cloneState(state);
+  const effects = [];
+  const reconcileEffects = reconcile(
+    next,
+    runningStates,
+    config.tracker.activeStates,
+    config.tracker.terminalStates
+  );
+  effects.push(...reconcileEffects);
+  for (const effect of reconcileEffects) {
+    if (effect.type === "stop") {
+      next.running.delete(effect.issueId);
+    }
+    if (effect.type === "releaseClaim") {
+      next.claimed.delete(effect.issueId);
+    }
+  }
+  const eligible = selectCandidates(
+    candidates,
+    next,
+    config.tracker.activeStates,
+    config.tracker.terminalStates
+  );
+  for (const issue of eligible) {
+    if (!canDispatch(next, issue.state, config.agent.maxConcurrentAgentsByState)) {
+      break;
+    }
+    next.claimed.add(issue.id);
+    next.running.set(issue.id, {
+      issueId: issue.id,
+      identifier: issue.identifier,
+      issue,
+      attempt: null,
+      workspacePath: "",
+      startedAt: new Date(nowMs).toISOString(),
+      phase: "PreparingWorkspace",
+      session: null
+    });
+    effects.push({
+      type: "dispatch",
+      issue,
+      attempt: null
+    });
+  }
+  return { nextState: next, effects };
+}
+function handleWorkerExit(state, issueId, reason, error, attempt, config) {
+  const next = cloneState(state);
+  const effects = [];
+  const entry = next.running.get(issueId);
+  next.running.delete(issueId);
+  if (reason === "normal") {
+    next.completed.add(issueId);
+    const delayMs = calculateRetryDelay(1, "continuation");
+    effects.push({
+      type: "scheduleRetry",
+      issueId,
+      identifier: entry?.identifier ?? issueId,
+      attempt: 1,
+      delayMs,
+      error: null
+    });
+  } else {
+    const nextAttempt = (attempt ?? 0) + 1;
+    const delayMs = calculateRetryDelay(nextAttempt, "failure", config.agent.maxRetryBackoffMs);
+    effects.push({
+      type: "scheduleRetry",
+      issueId,
+      identifier: entry?.identifier ?? issueId,
+      attempt: nextAttempt,
+      delayMs,
+      error: error ?? "unknown error"
+    });
+  }
+  return { nextState: next, effects };
+}
+function handleAgentUpdate(state, issueId, event) {
+  const next = cloneState(state);
+  const effects = [];
+  const entry = next.running.get(issueId);
+  if (entry && entry.session) {
+    const updatedSession = { ...entry.session };
+    updatedSession.lastEvent = event.type;
+    updatedSession.lastTimestamp = event.timestamp;
+    if (event.usage) {
+      updatedSession.inputTokens += event.usage.inputTokens;
+      updatedSession.outputTokens += event.usage.outputTokens;
+      updatedSession.totalTokens += event.usage.totalTokens;
+      effects.push({
+        type: "updateTokens",
+        issueId,
+        usage: event.usage
+      });
+    }
+    if (event.sessionId) {
+      updatedSession.sessionId = event.sessionId;
+    }
+    next.running.set(issueId, { ...entry, session: updatedSession });
+  }
+  return { nextState: next, effects };
+}
+function handleRetryFired(state, issueId, candidates, config, nowMs) {
+  const next = cloneState(state);
+  const effects = [];
+  const retryEntry = next.retryAttempts.get(issueId);
+  next.retryAttempts.delete(issueId);
+  if (!retryEntry) {
+    return { nextState: next, effects };
+  }
+  const issue = candidates.find((c) => c.id === issueId);
+  if (!issue) {
+    next.claimed.delete(issueId);
+    effects.push({ type: "releaseClaim", issueId });
+    return { nextState: next, effects };
+  }
+  const normalizedState = issue.state.toLowerCase();
+  const normalizedActive = config.tracker.activeStates.map((s) => s.toLowerCase());
+  if (!normalizedActive.includes(normalizedState)) {
+    next.claimed.delete(issueId);
+    effects.push({ type: "releaseClaim", issueId });
+    return { nextState: next, effects };
+  }
+  if (!canDispatch(next, issue.state, config.agent.maxConcurrentAgentsByState)) {
+    const nextAttempt = retryEntry.attempt + 1;
+    const delayMs = calculateRetryDelay(nextAttempt, "failure", config.agent.maxRetryBackoffMs);
+    next.retryAttempts.set(issueId, {
+      issueId,
+      identifier: retryEntry.identifier,
+      attempt: nextAttempt,
+      dueAtMs: nowMs + delayMs,
+      error: "no available orchestrator slots"
+    });
+    effects.push({
+      type: "scheduleRetry",
+      issueId,
+      identifier: retryEntry.identifier,
+      attempt: nextAttempt,
+      delayMs,
+      error: "no available orchestrator slots"
+    });
+    return { nextState: next, effects };
+  }
+  effects.push({
+    type: "dispatch",
+    issue,
+    attempt: retryEntry.attempt
+  });
+  return { nextState: next, effects };
+}
+function handleStallDetected(state, issueId, config) {
+  const next = cloneState(state);
+  const effects = [];
+  const entry = next.running.get(issueId);
+  next.running.delete(issueId);
+  const attempt = (entry?.attempt ?? 0) + 1;
+  const delayMs = calculateRetryDelay(attempt, "failure", config.agent.maxRetryBackoffMs);
+  effects.push({
+    type: "stop",
+    issueId,
+    reason: "stall_detected"
+  });
+  effects.push({
+    type: "scheduleRetry",
+    issueId,
+    identifier: entry?.identifier ?? issueId,
+    attempt,
+    delayMs,
+    error: "stall detected"
+  });
+  return { nextState: next, effects };
+}
+function applyEvent(state, event, config) {
+  switch (event.type) {
+    case "tick":
+      return handleTick(state, event.candidates, event.runningStates, config, event.nowMs);
+    case "worker_exit":
+      return handleWorkerExit(
+        state,
+        event.issueId,
+        event.reason,
+        event.error,
+        event.attempt,
+        config
+      );
+    case "agent_update":
+      return handleAgentUpdate(state, event.issueId, event.event);
+    case "retry_fired":
+      return handleRetryFired(state, event.issueId, event.candidates, config, event.nowMs);
+    case "stall_detected":
+      return handleStallDetected(state, event.issueId, config);
+  }
+}
+
+// src/core/state-helpers.ts
+function createEmptyState(config) {
+  return {
+    pollIntervalMs: config.polling.intervalMs,
+    maxConcurrentAgents: config.agent.maxConcurrentAgents,
+    running: /* @__PURE__ */ new Map(),
+    claimed: /* @__PURE__ */ new Set(),
+    retryAttempts: /* @__PURE__ */ new Map(),
+    completed: /* @__PURE__ */ new Set(),
+    tokenTotals: {
+      inputTokens: 0,
+      outputTokens: 0,
+      totalTokens: 0,
+      secondsRunning: 0
+    },
+    rateLimits: {
+      requestsRemaining: null,
+      requestsLimit: null,
+      tokensRemaining: null,
+      tokensLimit: null
+    }
+  };
+}
+
+// src/workflow/loader.ts
+import * as fs from "fs/promises";
+import { parse } from "yaml";
+import { Ok as Ok2, Err as Err2 } from "@harness-engineering/types";
+
+// src/workflow/config.ts
+import { Ok, Err } from "@harness-engineering/types";
+function validateWorkflowConfig(config) {
+  if (!config || typeof config !== "object")
+    return Err(new Error("Config is missing or not an object"));
+  const c = config;
+  if (!c.tracker) return Err(new Error("Config is missing tracker section"));
+  if (!c.polling) return Err(new Error("Config is missing polling section"));
+  if (!c.workspace) return Err(new Error("Config is missing workspace section"));
+  if (!c.hooks) return Err(new Error("Config is missing hooks section"));
+  if (!c.agent) return Err(new Error("Config is missing agent section"));
+  if (!c.server) return Err(new Error("Config is missing server section"));
+  return Ok(config);
+}
+function getDefaultConfig() {
+  return {
+    tracker: {
+      kind: "roadmap",
+      filePath: "docs/roadmap.md",
+      activeStates: ["planned", "in-progress"],
+      terminalStates: ["done"]
+    },
+    polling: {
+      intervalMs: 3e4
+    },
+    workspace: {
+      root: ".harness/workspaces"
+    },
+    hooks: {
+      afterCreate: null,
+      beforeRun: null,
+      afterRun: null,
+      beforeRemove: null,
+      timeoutMs: 6e4
+    },
+    agent: {
+      backend: "mock",
+      maxConcurrentAgents: 1,
+      maxTurns: 10,
+      maxRetryBackoffMs: 5e3,
+      maxConcurrentAgentsByState: {},
+      turnTimeoutMs: 3e5,
+      readTimeoutMs: 3e4,
+      stallTimeoutMs: 6e4
+    },
+    server: {
+      port: 8080
+    }
+  };
+}
+
+// src/workflow/loader.ts
+var WorkflowLoader = class {
+  async loadWorkflow(filePath) {
+    try {
+      const content = await fs.readFile(filePath, "utf-8");
+      const parts = content.split("---");
+      if (parts.length < 3) {
+        return Err2(
+          new Error(
+            `Invalid WORKFLOW.md format at ${filePath}. Expected frontmatter surrounded by '---'.`
+          )
+        );
+      }
+      const yamlContent = parts[1].trim();
+      const promptTemplate = parts.slice(2).join("---").trim();
+      const configData = parse(yamlContent);
+      const configResult = validateWorkflowConfig(configData);
+      if (!configResult.ok) {
+        return Err2(configResult.error);
+      }
+      return Ok2({
+        config: configResult.value,
+        promptTemplate
+      });
+    } catch (error) {
+      return Err2(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+};
+
+// src/tracker/adapters/roadmap.ts
+import * as fs2 from "fs/promises";
+import { createHash } from "crypto";
+import { parseRoadmap } from "@harness-engineering/core";
+import {
+  Ok as Ok3,
+  Err as Err3
+} from "@harness-engineering/types";
+var RoadmapTrackerAdapter = class {
+  config;
+  /**
+   * Creates a new RoadmapTrackerAdapter.
+   *
+   * @param config - The tracker configuration including the file path
+   */
+  constructor(config) {
+    this.config = config;
+    if (!config.filePath) {
+      throw new Error("RoadmapTrackerAdapter requires a filePath in TrackerConfig");
+    }
+  }
+  /**
+   * Fetches all issues that are in an "active" state according to the config.
+   */
+  async fetchCandidateIssues() {
+    return this.fetchIssuesByStates(this.config.activeStates);
+  }
+  /**
+   * Fetches issues that match any of the given state names.
+   *
+   * @param stateNames - List of statuses to filter by
+   */
+  async fetchIssuesByStates(stateNames) {
+    try {
+      if (!this.config.filePath) return Err3(new Error("Missing filePath"));
+      const content = await fs2.readFile(this.config.filePath, "utf-8");
+      const roadmapResult = parseRoadmap(content);
+      if (!roadmapResult.ok) return roadmapResult;
+      const issues = [];
+      for (const milestone of roadmapResult.value.milestones) {
+        for (const feature of milestone.features) {
+          if (stateNames.includes(feature.status)) {
+            issues.push(this.mapFeatureToIssue(feature));
+          }
+        }
+      }
+      return Ok3(issues);
+    } catch (error) {
+      return Err3(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Fetches full issue details for a list of identifiers.
+   *
+   * @param issueIds - List of issue IDs to fetch
+   */
+  async fetchIssueStatesByIds(issueIds) {
+    try {
+      if (!this.config.filePath) return Err3(new Error("Missing filePath"));
+      const content = await fs2.readFile(this.config.filePath, "utf-8");
+      const roadmapResult = parseRoadmap(content);
+      if (!roadmapResult.ok) return roadmapResult;
+      const issueMap = /* @__PURE__ */ new Map();
+      for (const milestone of roadmapResult.value.milestones) {
+        for (const feature of milestone.features) {
+          const issue = this.mapFeatureToIssue(feature);
+          if (issueIds.includes(issue.id)) {
+            issueMap.set(issue.id, issue);
+          }
+        }
+      }
+      return Ok3(issueMap);
+    } catch (error) {
+      return Err3(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Maps a raw RoadmapFeature from the parser to the unified Issue model.
+   */
+  mapFeatureToIssue(feature) {
+    const id = this.generateId(feature.name);
+    return {
+      id,
+      identifier: id,
+      title: feature.name,
+      description: feature.summary,
+      priority: null,
+      state: feature.status,
+      branchName: null,
+      url: null,
+      labels: [],
+      blockedBy: feature.blockedBy.map((b) => ({
+        id: this.generateId(b),
+        identifier: b,
+        state: null
+      })),
+      createdAt: null,
+      updatedAt: null
+    };
+  }
+  /**
+   * Generates a deterministic, URL-safe identifier for a feature name.
+   */
+  generateId(name) {
+    const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
+    const sanitized = name.toLowerCase().replace(/[^a-z0-9]+/g, "-").slice(0, 20);
+    return `${sanitized}-${hash}`;
+  }
+};
+
+// src/tracker/extensions/linear.ts
+import { Ok as Ok4 } from "@harness-engineering/types";
+var LinearGraphQLStub = class {
+  async query(query, _variables) {
+    console.log("Linear GraphQL query (stub):", query);
+    return Ok4({ data: {} });
+  }
+};
+
+// src/workspace/manager.ts
+import * as fs3 from "fs/promises";
+import * as path from "path";
+import { Ok as Ok5, Err as Err4 } from "@harness-engineering/types";
+var WorkspaceManager = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Sanitizes an issue identifier to be safe for use as a directory name.
+   */
+  sanitizeIdentifier(identifier) {
+    return identifier.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64);
+  }
+  /**
+   * Resolves the full path for an issue's workspace.
+   */
+  resolvePath(identifier) {
+    const sanitized = this.sanitizeIdentifier(identifier);
+    return path.join(this.config.root, sanitized);
+  }
+  /**
+   * Ensures the workspace directory exists.
+   */
+  async ensureWorkspace(identifier) {
+    try {
+      const workspacePath = this.resolvePath(identifier);
+      await fs3.mkdir(workspacePath, { recursive: true });
+      return Ok5(workspacePath);
+    } catch (error) {
+      return Err4(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  /**
+   * Checks if a workspace exists.
+   */
+  async exists(identifier) {
+    try {
+      const workspacePath = this.resolvePath(identifier);
+      await fs3.access(workspacePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Removes a workspace directory.
+   */
+  async removeWorkspace(identifier) {
+    try {
+      const workspacePath = this.resolvePath(identifier);
+      await fs3.rm(workspacePath, { recursive: true, force: true });
+      return Ok5(void 0);
+    } catch (error) {
+      return Err4(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+};
+
+// src/workspace/hooks.ts
+import { spawn } from "child_process";
+import { Ok as Ok6, Err as Err5 } from "@harness-engineering/types";
+var WorkspaceHooks = class {
+  config;
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Executes a shell hook in the specified workspace directory.
+   */
+  async executeHook(hookName, cwd) {
+    const command = this.config[hookName];
+    if (!command) {
+      return Ok6(void 0);
+    }
+    return new Promise((resolve) => {
+      const child = spawn(command, {
+        shell: true,
+        cwd,
+        env: process.env
+      });
+      const timeout = setTimeout(() => {
+        child.kill();
+        resolve(Err5(new Error(`Hook ${hookName} timed out after ${this.config.timeoutMs}ms`)));
+      }, this.config.timeoutMs);
+      child.on("exit", (code) => {
+        clearTimeout(timeout);
+        if (code === 0) {
+          resolve(Ok6(void 0));
+        } else {
+          resolve(Err5(new Error(`Hook ${hookName} failed with exit code ${code}`)));
+        }
+      });
+      child.on("error", (error) => {
+        clearTimeout(timeout);
+        resolve(Err5(error));
+      });
+    });
+  }
+  async afterCreate(cwd) {
+    return this.executeHook("afterCreate", cwd);
+  }
+  async beforeRun(cwd) {
+    return this.executeHook("beforeRun", cwd);
+  }
+  async afterRun(cwd) {
+    return this.executeHook("afterRun", cwd);
+  }
+  async beforeRemove(cwd) {
+    return this.executeHook("beforeRemove", cwd);
+  }
+};
+
+// src/agent/backends/mock.ts
+import {
+  Ok as Ok7
+} from "@harness-engineering/types";
+var MockBackend = class {
+  name = "mock";
+  async startSession(params) {
+    const session = {
+      sessionId: `mock-session-${Date.now()}`,
+      workspacePath: params.workspacePath,
+      backendName: this.name,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return Ok7(session);
+  }
+  async *runTurn(session, _params) {
+    yield {
+      type: "status",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: "Thinking...",
+      sessionId: session.sessionId
+    };
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    yield {
+      type: "thought",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      content: "I will list the directory.",
+      sessionId: session.sessionId
+    };
+    return {
+      success: true,
+      sessionId: session.sessionId,
+      usage: {
+        inputTokens: 100,
+        outputTokens: 50,
+        totalTokens: 150
+      }
+    };
+  }
+  async stopSession(_session) {
+    return Ok7(void 0);
+  }
+  async healthCheck() {
+    return Ok7(void 0);
+  }
+};
+
+// src/agent/backends/claude.ts
+import { spawn as spawn2 } from "child_process";
+import * as readline from "readline";
+import {
+  Ok as Ok8,
+  Err as Err6
+} from "@harness-engineering/types";
+var ClaudeBackend = class {
+  name = "claude";
+  command;
+  constructor(command = "claude") {
+    this.command = command;
+  }
+  async startSession(params) {
+    const session = {
+      sessionId: `claude-session-${Date.now()}`,
+      workspacePath: params.workspacePath,
+      backendName: this.name,
+      startedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return Ok8(session);
+  }
+  async *runTurn(session, params) {
+    const args = ["-p", params.prompt, "--output-format", "json"];
+    if (params.isContinuation) {
+      args.push("--resume", session.sessionId);
+    }
+    const child = spawn2(this.command, args, {
+      cwd: session.workspacePath,
+      env: process.env
+    });
+    const rl = readline.createInterface({
+      input: child.stdout,
+      terminal: false
+    });
+    let lastResult = null;
+    try {
+      for await (const line of rl) {
+        try {
+          const event = JSON.parse(line);
+          yield event;
+          if (event.type === "result") {
+            lastResult = event.content;
+          }
+        } catch {
+        }
+      }
+    } finally {
+      if (child.exitCode === null) {
+        child.kill("SIGTERM");
+      }
+      rl.close();
+    }
+    return lastResult || {
+      success: true,
+      sessionId: session.sessionId,
+      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+    };
+  }
+  async stopSession(_session) {
+    return Ok8(void 0);
+  }
+  async healthCheck() {
+    return new Promise((resolve) => {
+      const child = spawn2(this.command, ["--version"]);
+      child.on("exit", (code) => {
+        if (code === 0) {
+          resolve(Ok8(void 0));
+        } else {
+          resolve(
+            Err6({
+              category: "agent_not_found",
+              message: `Claude command '${this.command}' not found or failed`
+            })
+          );
+        }
+      });
+      child.on("error", () => {
+        resolve(
+          Err6({
+            category: "agent_not_found",
+            message: `Claude command '${this.command}' not found`
+          })
+        );
+      });
+    });
+  }
+};
+
+// src/prompt/renderer.ts
+import { Liquid } from "liquidjs";
+var PromptRenderer = class {
+  engine;
+  constructor() {
+    this.engine = new Liquid({
+      strictVariables: true,
+      strictFilters: true
+    });
+  }
+  async render(template, context) {
+    try {
+      return await this.engine.render(this.engine.parse(template), context);
+    } catch (error) {
+      if (error instanceof Error) {
+        throw new Error(`Template rendering failed: ${error.message}`, { cause: error });
+      }
+      throw error;
+    }
+  }
+};
+
+// src/orchestrator.ts
+import { EventEmitter } from "events";
+
+// src/agent/runner.ts
+var AgentRunner = class {
+  backend;
+  options;
+  constructor(backend, options) {
+    this.backend = backend;
+    this.options = options;
+  }
+  /**
+   * Run a multi-turn agent session for an issue.
+   */
+  async *runSession(_issue, workspacePath, prompt) {
+    const startResult = await this.backend.startSession({
+      workspacePath,
+      permissionMode: "full"
+      // Default for now
+    });
+    if (!startResult.ok) {
+      throw new Error(`Failed to start agent session: ${startResult.error.message}`);
+    }
+    const session = startResult.value;
+    let currentTurn = 0;
+    let lastResult = {
+      success: false,
+      sessionId: session.sessionId,
+      usage: { inputTokens: 0, outputTokens: 0, totalTokens: 0 }
+    };
+    try {
+      while (currentTurn < this.options.maxTurns) {
+        currentTurn++;
+        const turnParams = {
+          sessionId: session.sessionId,
+          prompt: currentTurn === 1 ? prompt : "Continue your work.",
+          isContinuation: currentTurn > 1
+        };
+        const turnGen = this.backend.runTurn(session, turnParams);
+        let next = await turnGen.next();
+        while (!next.done) {
+          yield next.value;
+          next = await turnGen.next();
+        }
+        lastResult = next.value;
+        if (lastResult.success) {
+          break;
+        }
+      }
+    } finally {
+      await this.backend.stopSession(session);
+    }
+    return lastResult;
+  }
+};
+
+// src/server/http.ts
+import * as http from "http";
+var OrchestratorServer = class {
+  server;
+  orchestrator;
+  port;
+  constructor(orchestrator, port) {
+    this.orchestrator = orchestrator;
+    this.port = port;
+    this.server = http.createServer(this.handleRequest.bind(this));
+  }
+  handleRequest(req, res) {
+    const { method, url } = req;
+    if (method === "GET" && url === "/api/v1/state") {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end(JSON.stringify(this.orchestrator.getSnapshot()));
+      return;
+    }
+    res.writeHead(404, { "Content-Type": "application/json" });
+    res.end(JSON.stringify({ error: "Not Found" }));
+  }
+  async start() {
+    return new Promise((resolve) => {
+      this.server.listen(this.port, "127.0.0.1", () => {
+        console.log(`Orchestrator API listening on localhost:${this.port}`);
+        resolve();
+      });
+    });
+  }
+  stop() {
+    this.server.close();
+  }
+};
+
+// src/logging/logger.ts
+var StructuredLogger = class {
+  info(message, context) {
+    this.log("info", message, context);
+  }
+  warn(message, context) {
+    this.log("warn", message, context);
+  }
+  error(message, context) {
+    this.log("error", message, context);
+  }
+  log(level, message, context) {
+    const entry = {
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...context ? { context } : {}
+    };
+    console.log(this.formatLog(entry));
+  }
+  formatLog(entry) {
+    const timestamp = entry.timestamp || (/* @__PURE__ */ new Date()).toISOString();
+    const contextStr = entry.context ? ` ${this.safeStringify(entry.context)}` : "";
+    return `${timestamp} ${entry.level.toUpperCase()}: ${entry.message}${contextStr}`;
+  }
+  safeStringify(obj) {
+    try {
+      return JSON.stringify(obj);
+    } catch {
+      return "[Circular or Non-serializable]";
+    }
+  }
+};
+
+// src/orchestrator.ts
+var Orchestrator = class extends EventEmitter {
+  state;
+  config;
+  tracker;
+  workspace;
+  hooks;
+  runner;
+  renderer;
+  promptTemplate;
+  server;
+  interval;
+  logger;
+  /**
+   * Creates a new Orchestrator instance.
+   *
+   * @param config - The workflow configuration
+   * @param promptTemplate - The template used to generate agent instructions
+   * @param overrides - Optional dependency overrides for testing or custom behavior
+   */
+  constructor(config, promptTemplate, overrides) {
+    super();
+    this.config = config;
+    this.promptTemplate = promptTemplate;
+    this.state = createEmptyState(config);
+    this.logger = new StructuredLogger();
+    this.tracker = overrides?.tracker || this.createTracker();
+    this.workspace = new WorkspaceManager(config.workspace);
+    this.hooks = new WorkspaceHooks(config.hooks);
+    this.renderer = new PromptRenderer();
+    this.runner = new AgentRunner(overrides?.backend || this.createBackend(), {
+      maxTurns: config.agent.maxTurns
+    });
+    if (config.server?.port) {
+      this.server = new OrchestratorServer(this, config.server.port);
+    }
+  }
+  createTracker() {
+    if (this.config.tracker.kind === "roadmap") {
+      return new RoadmapTrackerAdapter(this.config.tracker);
+    }
+    throw new Error(`Unsupported tracker kind: ${this.config.tracker.kind}`);
+  }
+  createBackend() {
+    if (this.config.agent.backend === "mock") {
+      return new MockBackend();
+    } else if (this.config.agent.backend === "claude") {
+      return new ClaudeBackend(this.config.agent.command);
+    }
+    throw new Error(`Unsupported agent backend: ${this.config.agent.backend}`);
+  }
+  /**
+   * Run a single tick of the orchestrator loop.
+   *
+   * This method fetches the latest issue states, applies them to the state machine,
+   * and executes any resulting side effects (dispatching new agents, stopping agents, etc.).
+   */
+  async tick() {
+    const candidatesResult = await this.tracker.fetchCandidateIssues();
+    if (!candidatesResult.ok) {
+      this.logger.error("Failed to fetch candidate issues", {
+        error: String(candidatesResult.error)
+      });
+      return;
+    }
+    const runningIds = Array.from(this.state.running.keys());
+    const runningStatesResult = await this.tracker.fetchIssueStatesByIds(runningIds);
+    if (!runningStatesResult.ok) {
+      this.logger.error("Failed to fetch running issue states", {
+        error: String(runningStatesResult.error)
+      });
+      return;
+    }
+    const tickEvent = {
+      type: "tick",
+      candidates: candidatesResult.value,
+      runningStates: runningStatesResult.value,
+      nowMs: Date.now()
+    };
+    const { nextState, effects } = applyEvent(this.state, tickEvent, this.config);
+    this.state = nextState;
+    for (const effect of effects) {
+      await this.handleEffect(effect);
+    }
+    this.emit("state_change", this.getSnapshot());
+  }
+  /**
+   * Processes a side effect generated by the state machine.
+   *
+   * @param effect - The effect to handle
+   */
+  async handleEffect(effect) {
+    switch (effect.type) {
+      case "dispatch":
+        await this.dispatchIssue(effect.issue, effect.attempt);
+        break;
+      case "stop":
+        await this.stopIssue(effect.issueId);
+        break;
+      case "updateTokens":
+        break;
+      case "emitLog":
+        this.logger.log(effect.level, effect.message, effect.context);
+        break;
+      case "releaseClaim":
+        break;
+      case "cleanWorkspace":
+        await this.workspace.removeWorkspace(effect.identifier);
+        break;
+    }
+  }
+  /**
+   * Dispatches a new agent to work on an issue.
+   *
+   * @param issue - The issue to resolve
+   * @param attempt - The retry attempt number
+   */
+  async dispatchIssue(issue, attempt) {
+    this.logger.info(`Dispatching issue: ${issue.identifier} (attempt ${attempt})`, {
+      issueId: issue.id
+    });
+    try {
+      const workspaceResult = await this.workspace.ensureWorkspace(issue.identifier);
+      if (!workspaceResult.ok) throw workspaceResult.error;
+      const workspacePath = workspaceResult.value;
+      const hookResult = await this.hooks.beforeRun(workspacePath);
+      if (!hookResult.ok) throw hookResult.error;
+      const prompt = await this.renderer.render(this.promptTemplate, {
+        issue,
+        attempt: attempt || 1
+      });
+      this.runAgentInBackgroundTask(issue, workspacePath, prompt, attempt);
+    } catch (error) {
+      this.logger.error(`Dispatch failed for ${issue.identifier}`, { error: String(error) });
+      await this.emitWorkerExit(issue.id, "error", attempt, String(error));
+    }
+  }
+  /**
+   * Runs an agent session in a background task to avoid blocking the main loop.
+   */
+  runAgentInBackgroundTask(issue, workspacePath, prompt, attempt) {
+    (async () => {
+      try {
+        const sessionGen = this.runner.runSession(issue, workspacePath, prompt);
+        for await (const event of sessionGen) {
+          this.emit("agent_event", { issueId: issue.id, event });
+        }
+        await this.emitWorkerExit(issue.id, "normal", attempt);
+      } catch (error) {
+        this.logger.error(`Agent runner failed for ${issue.identifier}`, { error: String(error) });
+        await this.emitWorkerExit(issue.id, "error", attempt, String(error));
+      }
+    })().catch((err) => {
+      this.logger.error("Fatal error in background task", { error: String(err) });
+    });
+  }
+  /**
+   * Informs the state machine that an agent worker has exited.
+   */
+  async emitWorkerExit(issueId, reason, attempt, error) {
+    const event = {
+      type: "worker_exit",
+      issueId,
+      reason,
+      error,
+      attempt
+    };
+    const { nextState, effects } = applyEvent(this.state, event, this.config);
+    this.state = nextState;
+    for (const effect of effects) {
+      await this.handleEffect(effect);
+    }
+    this.emit("state_change", this.getSnapshot());
+  }
+  /**
+   * Stops execution for a specific issue.
+   *
+   * @param issueId - The ID of the issue to stop
+   */
+  async stopIssue(issueId) {
+    this.logger.info(`Stopping issue: ${issueId}`);
+  }
+  /**
+   * Starts the polling loop and the internal HTTP server.
+   */
+  start() {
+    if (this.server) {
+      void this.server.start();
+    }
+    const intervalMs = this.config.polling.intervalMs || 3e4;
+    this.interval = setInterval(() => {
+      void this.tick();
+    }, intervalMs);
+    void this.tick();
+  }
+  /**
+   * Stops the orchestrator, clearing the polling interval and stopping the server.
+   */
+  async stop() {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = void 0;
+    }
+    if (this.server) {
+      this.server.stop();
+    }
+    this.logger.info("Orchestrator stopped.");
+  }
+  /**
+   * Returns a point-in-time snapshot of the orchestrator's internal state.
+   */
+  getSnapshot() {
+    return {
+      running: Array.from(this.state.running.entries()),
+      retryAttempts: Array.from(this.state.retryAttempts.entries()),
+      claimed: Array.from(this.state.claimed),
+      tokenTotals: this.state.tokenTotals,
+      maxConcurrentAgents: this.state.maxConcurrentAgents
+    };
+  }
+};
+
+// src/tui/launcher.tsx
+import { render } from "ink";
+
+// src/tui/app.tsx
+import { useState as useState2, useEffect as useEffect2 } from "react";
+import { Box as Box4, Text as Text4, useApp, useInput } from "ink";
+
+// src/tui/components/Header.tsx
+import { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+var Header = () => {
+  const [uptime, setUptime] = useState(0);
+  useEffect(() => {
+    const timer = setInterval(() => {
+      setUptime((prev) => prev + 1);
+    }, 1e3);
+    return () => clearInterval(timer);
+  }, []);
+  const formatUptime = (seconds) => {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor(seconds % 3600 / 60);
+    const s = seconds % 60;
+    return `${h}h ${m}m ${s}s`;
+  };
+  return /* @__PURE__ */ jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, justifyContent: "space-between", children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: "cyan", children: "Harness Orchestrator" }),
+    /* @__PURE__ */ jsxs(Text, { children: [
+      "Uptime: ",
+      formatUptime(uptime)
+    ] })
+  ] });
+};
+
+// src/tui/components/Stats.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var Stats = ({ tokenTotals, runningCount, maxConcurrency }) => {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "row", paddingX: 1, gap: 4, children: [
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Concurrency" }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "Active: ",
+        /* @__PURE__ */ jsx2(Text2, { color: runningCount > 0 ? "green" : "gray", children: runningCount }),
+        " /",
+        " ",
+        maxConcurrency
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Token Usage" }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "Input: ",
+        /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: tokenTotals.inputTokens.toLocaleString() })
+      ] }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "Output: ",
+        /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: tokenTotals.outputTokens.toLocaleString() })
+      ] }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "Total: ",
+        /* @__PURE__ */ jsx2(Text2, { color: "yellow", children: tokenTotals.totalTokens.toLocaleString() })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", children: [
+      /* @__PURE__ */ jsx2(Text2, { bold: true, children: "Efficiency" }),
+      /* @__PURE__ */ jsxs2(Text2, { children: [
+        "Time Running: ",
+        /* @__PURE__ */ jsxs2(Text2, { color: "blue", children: [
+          Math.round(tokenTotals.secondsRunning),
+          "s"
+        ] })
+      ] })
+    ] })
+  ] });
+};
+
+// src/tui/components/AgentsTable.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var AgentsTable = ({ agents }) => {
+  if (agents.length === 0) {
+    return /* @__PURE__ */ jsx3(Box3, { paddingX: 1, marginY: 1, children: /* @__PURE__ */ jsx3(Text3, { color: "gray", italic: true, children: "No active agents." }) });
+  }
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginY: 1, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, underline: true, children: "Active Agents" }),
+    /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", borderStyle: "single", borderColor: "gray", children: [
+      /* @__PURE__ */ jsx3(Box3, { width: 20, children: /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Identifier" }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: 20, children: /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Phase" }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: 10, children: /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Tokens" }) }),
+      /* @__PURE__ */ jsx3(Box3, { flexGrow: 1, children: /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Message" }) })
+    ] }),
+    agents.map((agent) => /* @__PURE__ */ jsxs3(Box3, { flexDirection: "row", children: [
+      /* @__PURE__ */ jsx3(Box3, { width: 20, children: /* @__PURE__ */ jsx3(Text3, { children: agent.identifier }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: 20, children: /* @__PURE__ */ jsx3(Text3, { color: "cyan", children: agent.phase }) }),
+      /* @__PURE__ */ jsx3(Box3, { width: 10, children: /* @__PURE__ */ jsx3(Text3, { color: "yellow", children: agent.session?.totalTokens || 0 }) }),
+      /* @__PURE__ */ jsx3(Box3, { flexGrow: 1, children: /* @__PURE__ */ jsx3(Text3, { wrap: "truncate-end", children: agent.session?.lastMessage || "-" }) })
+    ] }, agent.issueId))
+  ] });
+};
+
+// src/tui/app.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var Dashboard = ({ orchestrator }) => {
+  const [state, setState] = useState2(orchestrator.getSnapshot());
+  const { exit } = useApp();
+  useEffect2(() => {
+    const handleStateChange = (newState) => {
+      setState(newState);
+    };
+    orchestrator.on("state_change", handleStateChange);
+    return () => {
+      orchestrator.off("state_change", handleStateChange);
+    };
+  }, [orchestrator]);
+  useInput((input, key) => {
+    if (input === "q" || key.ctrl && input === "c") {
+      orchestrator.stop();
+      exit();
+    }
+  });
+  const runningAgents = state.running.map(([_, entry]) => entry);
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", padding: 1, children: [
+    /* @__PURE__ */ jsx4(Header, {}),
+    /* @__PURE__ */ jsx4(
+      Stats,
+      {
+        tokenTotals: state.tokenTotals,
+        runningCount: state.running.length,
+        maxConcurrency: state.maxConcurrentAgents
+      }
+    ),
+    /* @__PURE__ */ jsx4(AgentsTable, { agents: runningAgents }),
+    /* @__PURE__ */ jsx4(Box4, { marginTop: 1, children: /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "Press 'q' to quit" }) })
+  ] });
+};
+
+// src/tui/launcher.tsx
+import { jsx as jsx5 } from "react/jsx-runtime";
+function launchTUI(orchestrator) {
+  const { waitUntilExit } = render(/* @__PURE__ */ jsx5(Dashboard, { orchestrator }));
+  return { waitUntilExit };
+}
+export {
+  ClaudeBackend,
+  LinearGraphQLStub,
+  MockBackend,
+  Orchestrator,
+  PromptRenderer,
+  RoadmapTrackerAdapter,
+  WorkflowLoader,
+  WorkspaceHooks,
+  WorkspaceManager,
+  applyEvent,
+  calculateRetryDelay,
+  canDispatch,
+  createEmptyState,
+  getAvailableSlots,
+  getDefaultConfig,
+  getPerStateCount,
+  isEligible,
+  launchTUI,
+  reconcile,
+  selectCandidates,
+  sortCandidates,
+  validateWorkflowConfig
+};