@flyingrobots/graft 0.4.0 → 0.6.0

package/src/mcp/daemon-worker-inline-pool.ts

@@ -0,0 +1,46 @@
+import { runMonitorTickJob, type MonitorTickWorkerJob, type MonitorTickWorkerResult } from "./monitor-tick-job.js";
+import { runRepoToolJob, type RepoToolWorkerJob, type RepoToolWorkerResult } from "./repo-tool-job.js";
+import type { DaemonWorkerCounts, DaemonWorkerPool } from "./daemon-worker-types.js";
+
+export class InlineDaemonWorkerPool implements DaemonWorkerPool {
+  private completedTasks = 0;
+  private failedTasks = 0;
+
+  getCounts(): DaemonWorkerCounts {
+    return {
+      mode: "inline",
+      totalWorkers: 0,
+      busyWorkers: 0,
+      idleWorkers: 0,
+      queuedTasks: 0,
+      completedTasks: this.completedTasks,
+      failedTasks: this.failedTasks,
+    };
+  }
+
+  async runMonitorTick(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult> {
+    try {
+      const result = await runMonitorTickJob(job);
+      this.completedTasks++;
+      return result;
+    } catch (error) {
+      this.failedTasks++;
+      throw error;
+    }
+  }
+
+  async runRepoTool(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult> {
+    try {
+      const result = await runRepoToolJob(job);
+      this.completedTasks++;
+      return result;
+    } catch (error) {
+      this.failedTasks++;
+      throw error;
+    }
+  }
+
+  close(): Promise<void> {
+    return Promise.resolve();
+  }
+}

package/src/mcp/daemon-worker-pool.ts

@@ -0,0 +1,7 @@
+export type {
+  DaemonWorkerCounts,
+  DaemonWorkerPool,
+  ChildProcessDaemonWorkerPoolOptions,
+} from "./daemon-worker-types.js";
+export { InlineDaemonWorkerPool } from "./daemon-worker-inline-pool.js";
+export { ChildProcessDaemonWorkerPool } from "./daemon-worker-child-pool.js";

package/src/mcp/daemon-worker-process.ts

@@ -0,0 +1,52 @@
+import { runMonitorTickJob, type MonitorTickWorkerJob, type MonitorTickWorkerResult } from "./monitor-tick-job.js";
+import { runRepoToolJob, type RepoToolWorkerJob, type RepoToolWorkerResult } from "./repo-tool-job.js";
+
+interface MonitorTickWorkerRequest {
+  readonly requestId: string;
+  readonly kind: "monitor_tick";
+  readonly job: MonitorTickWorkerJob;
+}
+
+interface RepoToolWorkerRequest {
+  readonly requestId: string;
+  readonly kind: "repo_tool";
+  readonly job: RepoToolWorkerJob;
+}
+
+interface WorkerSuccessMessage {
+  readonly requestId: string;
+  readonly ok: true;
+  readonly result: MonitorTickWorkerResult | RepoToolWorkerResult;
+}
+
+interface WorkerFailureMessage {
+  readonly requestId: string;
+  readonly ok: false;
+  readonly error: string;
+}
+
+type WorkerRequest = MonitorTickWorkerRequest | RepoToolWorkerRequest;
+type WorkerResponse = WorkerSuccessMessage | WorkerFailureMessage;
+
+process.on("message", (request: WorkerRequest) => {
+  void (async () => {
+    try {
+      const result = request.kind === "monitor_tick"
+        ? await runMonitorTickJob(request.job)
+        : await runRepoToolJob(request.job);
+      const response: WorkerResponse = {
+        requestId: request.requestId,
+        ok: true,
+        result,
+      };
+      process.send?.(response);
+    } catch (error) {
+      const response: WorkerResponse = {
+        requestId: request.requestId,
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      };
+      process.send?.(response);
+    }
+  })();
+});

package/src/mcp/daemon-worker-types.ts

@@ -0,0 +1,66 @@
+import type { MonitorTickWorkerJob, MonitorTickWorkerResult } from "./monitor-tick-job.js";
+import type { RepoToolWorkerJob, RepoToolWorkerResult } from "./repo-tool-job.js";
+import type { ChildProcess } from "node:child_process";
+
+export interface DaemonWorkerCounts {
+  readonly mode: "inline" | "child_processes";
+  readonly totalWorkers: number;
+  readonly busyWorkers: number;
+  readonly idleWorkers: number;
+  readonly queuedTasks: number;
+  readonly completedTasks: number;
+  readonly failedTasks: number;
+}
+
+export interface DaemonWorkerPool {
+  getCounts(): DaemonWorkerCounts;
+  runMonitorTick(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult>;
+  runRepoTool(job: RepoToolWorkerJob): Promise<RepoToolWorkerResult>;
+  close(): Promise<void>;
+}
+
+export interface ChildProcessDaemonWorkerPoolOptions {
+  readonly size?: number | undefined;
+}
+
+export interface QueuedMonitorTask {
+  readonly requestId: string;
+  readonly kind: "monitor_tick";
+  readonly job: MonitorTickWorkerJob;
+  readonly resolve: (result: MonitorTickWorkerResult) => void;
+  readonly reject: (reason?: unknown) => void;
+}
+
+export interface QueuedRepoToolTask {
+  readonly requestId: string;
+  readonly kind: "repo_tool";
+  readonly job: RepoToolWorkerJob;
+  readonly resolve: (result: RepoToolWorkerResult) => void;
+  readonly reject: (reason?: unknown) => void;
+}
+
+export type QueuedWorkerTask = QueuedMonitorTask | QueuedRepoToolTask;
+
+export type ActiveWorkerTask = QueuedWorkerTask & {
+  readonly workerId: string;
+};
+
+export interface WorkerSuccessMessage {
+  readonly requestId: string;
+  readonly ok: true;
+  readonly result: MonitorTickWorkerResult | RepoToolWorkerResult;
+}
+
+export interface WorkerFailureMessage {
+  readonly requestId: string;
+  readonly ok: false;
+  readonly error: string;
+}
+
+export type WorkerMessage = WorkerSuccessMessage | WorkerFailureMessage;
+
+export interface WorkerState {
+  readonly workerId: string;
+  readonly child: ChildProcess;
+  task: ActiveWorkerTask | null;
+}

package/src/mcp/metrics.ts

@@ -1,14 +1,71 @@
 // ---------------------------------------------------------------------------
-// Session metrics — replaces loose counters in server.ts
+// Session metrics — runtime-backed metric snapshots and deltas
 // ---------------------------------------------------------------------------
 
-export interface MetricsSnapshot {
+import type { McpToolName } from "../contracts/output-schemas.js";
+import {
+  BURDEN_KINDS,
+  emptyBurdenByKind,
+  freezeBurdenByKind,
+  burdenKindForTool,
+  cloneBurdenByKind,
+  type BurdenByKind,
+} from "./burden.js";
+
+export class MetricsSnapshot {
   readonly reads: number;
   readonly outlines: number;
   readonly refusals: number;
   readonly cacheHits: number;
   readonly bytesReturned: number;
   readonly bytesAvoided: number;
+  readonly burdenByKind: Readonly<BurdenByKind>;
+
+  constructor(fields: {
+    readonly reads: number;
+    readonly outlines: number;
+    readonly refusals: number;
+    readonly cacheHits: number;
+    readonly bytesReturned: number;
+    readonly bytesAvoided: number;
+    readonly burdenByKind: Readonly<BurdenByKind>;
+  }) {
+    this.reads = fields.reads;
+    this.outlines = fields.outlines;
+    this.refusals = fields.refusals;
+    this.cacheHits = fields.cacheHits;
+    this.bytesReturned = fields.bytesReturned;
+    this.bytesAvoided = fields.bytesAvoided;
+    this.burdenByKind = fields.burdenByKind;
+  }
+}
+
+export class MetricsDelta {
+  readonly reads: number;
+  readonly outlines: number;
+  readonly refusals: number;
+  readonly cacheHits: number;
+  readonly bytesReturned: number;
+  readonly bytesAvoided: number;
+  readonly burdenByKind: Readonly<BurdenByKind>;
+
+  constructor(fields: {
+    readonly reads: number;
+    readonly outlines: number;
+    readonly refusals: number;
+    readonly cacheHits: number;
+    readonly bytesReturned: number;
+    readonly bytesAvoided: number;
+    readonly burdenByKind: Readonly<BurdenByKind>;
+  }) {
+    this.reads = fields.reads;
+    this.outlines = fields.outlines;
+    this.refusals = fields.refusals;
+    this.cacheHits = fields.cacheHits;
+    this.bytesReturned = fields.bytesReturned;
+    this.bytesAvoided = fields.bytesAvoided;
+    this.burdenByKind = fields.burdenByKind;
+  }
 }
 
 export class Metrics {
@@ -18,6 +75,19 @@ export class Metrics {
   private totalCacheHits = 0;
   private totalBytesAvoidedByCache = 0;
   private cumulativeBytesReturned = 0;
+  private burdenByKind: BurdenByKind = emptyBurdenByKind();
+
+  static fromSnapshot(snapshot: MetricsSnapshot): Metrics {
+    const metrics = new Metrics();
+    metrics.totalReads = snapshot.reads;
+    metrics.totalOutlines = snapshot.outlines;
+    metrics.totalRefusals = snapshot.refusals;
+    metrics.totalCacheHits = snapshot.cacheHits;
+    metrics.totalBytesAvoidedByCache = snapshot.bytesAvoided;
+    metrics.cumulativeBytesReturned = snapshot.bytesReturned;
+    metrics.burdenByKind = cloneBurdenByKind(snapshot.burdenByKind);
+    return metrics;
+  }
 
   recordRead(): void {
     this.totalReads++;
@@ -36,18 +106,71 @@ export class Metrics {
     this.totalBytesAvoidedByCache += bytesAvoided;
   }
 
-  addBytesReturned(n: number): void {
+  recordToolResult(tool: McpToolName, n: number): void {
     this.cumulativeBytesReturned += n;
+    const kind = burdenKindForTool(tool);
+    const current = this.burdenByKind[kind];
+    this.burdenByKind = {
+      ...this.burdenByKind,
+      [kind]: {
+        calls: current.calls + 1,
+        bytesReturned: current.bytesReturned + n,
+      },
+    };
+  }
+
+  applyDelta(delta: MetricsDelta): void {
+    this.totalReads += delta.reads;
+    this.totalOutlines += delta.outlines;
+    this.totalRefusals += delta.refusals;
+    this.totalCacheHits += delta.cacheHits;
+    this.totalBytesAvoidedByCache += delta.bytesAvoided;
+    this.cumulativeBytesReturned += delta.bytesReturned;
+    const merged = cloneBurdenByKind(this.burdenByKind);
+    for (const kind of BURDEN_KINDS) {
+      merged[kind] = {
+        calls: this.burdenByKind[kind].calls + delta.burdenByKind[kind].calls,
+        bytesReturned:
+          this.burdenByKind[kind].bytesReturned +
+          delta.burdenByKind[kind].bytesReturned,
+      };
+    }
+    this.burdenByKind = merged;
   }
 
   snapshot(): MetricsSnapshot {
-    return {
+    return new MetricsSnapshot({
       reads: this.totalReads,
       outlines: this.totalOutlines,
       refusals: this.totalRefusals,
       cacheHits: this.totalCacheHits,
       bytesReturned: this.cumulativeBytesReturned,
       bytesAvoided: this.totalBytesAvoidedByCache,
+      burdenByKind: freezeBurdenByKind(cloneBurdenByKind(this.burdenByKind)),
+    });
+  }
+}
+
+export function diffMetrics(
+  before: MetricsSnapshot,
+  after: MetricsSnapshot,
+): MetricsDelta {
+  const burdenDelta = emptyBurdenByKind();
+  for (const kind of BURDEN_KINDS) {
+    burdenDelta[kind] = {
+      calls: after.burdenByKind[kind].calls - before.burdenByKind[kind].calls,
+      bytesReturned:
+        after.burdenByKind[kind].bytesReturned -
+        before.burdenByKind[kind].bytesReturned,
     };
   }
+  return new MetricsDelta({
+    reads: after.reads - before.reads,
+    outlines: after.outlines - before.outlines,
+    refusals: after.refusals - before.refusals,
+    cacheHits: after.cacheHits - before.cacheHits,
+    bytesReturned: after.bytesReturned - before.bytesReturned,
+    bytesAvoided: after.bytesAvoided - before.bytesAvoided,
+    burdenByKind: freezeBurdenByKind(burdenDelta),
+  });
 }

package/src/mcp/monitor-health.ts

@@ -0,0 +1,83 @@
+import type {
+  MonitorHealth,
+  MonitorLifecycleState,
+  MonitorStatusView,
+  PersistedMonitorRecord,
+} from "./monitor-types.js";
+
+/**
+ * Derive the health value for a monitor based on its lifecycle state and
+ * an optional tick result.
+ *
+ * When the lifecycle is paused or stopped the health always matches the
+ * lifecycle.  Otherwise the caller supplies the "active" health that
+ * reflects what happened during the tick.
+ */
+export function deriveHealth(
+  lifecycleState: MonitorLifecycleState,
+  activeHealth: MonitorHealth,
+): MonitorHealth {
+  if (lifecycleState === "paused") return "paused";
+  if (lifecycleState === "stopped") return "stopped";
+  return activeHealth;
+}
+
+/**
+ * Derive the health to assign after a lifecycle transition (pause/stop/resume).
+ */
+export function deriveTransitionHealth(
+  lifecycleState: MonitorLifecycleState,
+): MonitorHealth {
+  if (lifecycleState === "paused") return "paused";
+  if (lifecycleState === "stopped") return "stopped";
+  return "lagging";
+}
+
+/**
+ * Normalize a poll interval value, falling back to the provided default.
+ * Throws if the value is not a positive finite integer.
+ */
+export function normalizePollIntervalMs(value: number | undefined, fallback: number): number {
+  if (value === undefined) return fallback;
+  const normalized = Math.trunc(value);
+  if (!Number.isFinite(normalized) || normalized <= 0) {
+    throw new Error("pollIntervalMs must be a positive integer");
+  }
+  return normalized;
+}
+
+/**
+ * Sort an array of monitor status views by gitCommonDir for deterministic output.
+ */
+export function sortStatuses(statuses: readonly MonitorStatusView[]): readonly MonitorStatusView[] {
+  return [...statuses].sort((left, right) => left.gitCommonDir.localeCompare(right.gitCommonDir));
+}
+
+/**
+ * Project a persisted record plus an authorized-workspace count into a
+ * read-only status view.
+ */
+export function toStatusView(
+  record: PersistedMonitorRecord,
+  authorizedWorkspaces: number,
+): MonitorStatusView {
+  return {
+    repoId: record.repoId,
+    gitCommonDir: record.gitCommonDir,
+    anchorWorktreeRoot: record.anchorWorktreeRoot,
+    authorizedWorkspaces,
+    workerKind: record.workerKind,
+    lifecycleState: record.lifecycleState,
+    health: record.health,
+    pollIntervalMs: record.pollIntervalMs,
+    lastStartedAt: record.lastStartedAt,
+    lastTickAt: record.lastTickAt,
+    lastSuccessAt: record.lastSuccessAt,
+    lastError: record.lastError,
+    lastIndexedCommit: record.lastIndexedCommit,
+    lastHeadCommit: record.lastHeadCommit,
+    backlogCommits: record.backlogCommits,
+    lastRunCommitsIndexed: record.lastRunCommitsIndexed,
+    lastRunPatchesWritten: record.lastRunPatchesWritten,
+  };
+}

package/src/mcp/monitor-persistence.ts

@@ -0,0 +1,54 @@
+import * as path from "node:path";
+import type { JsonCodec } from "../ports/codec.js";
+import type { FileSystem } from "../ports/filesystem.js";
+import {
+  persistedMonitorStateSchema,
+  type PersistedMonitorRecord,
+  type PersistedMonitorState,
+} from "./monitor-types.js";
+
+/**
+ * Clone a persisted monitor record (shallow copy — all fields are primitives).
+ */
+export function cloneRecord(record: PersistedMonitorRecord): PersistedMonitorRecord {
+  return { ...record };
+}
+
+/**
+ * Load monitor records from disk.
+ * Returns an empty array when the file does not exist yet.
+ */
+export async function loadMonitorRecords(
+  fs: FileSystem,
+  codec: JsonCodec,
+  statePath: string,
+): Promise<readonly PersistedMonitorRecord[]> {
+  const raw = await fs.readFile(statePath, "utf-8").catch((error: unknown) => {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
+  });
+  if (raw === null) return [];
+  const decoded = persistedMonitorStateSchema.parse(codec.decode(raw));
+  return decoded.monitors.map(cloneRecord);
+}
+
+/**
+ * Persist monitor records to disk, creating parent directories as needed.
+ */
+export async function persistMonitorRecords(
+  fs: FileSystem,
+  codec: JsonCodec,
+  statePath: string,
+  records: ReadonlyMap<string, PersistedMonitorRecord>,
+): Promise<void> {
+  const payload: PersistedMonitorState = {
+    version: 1,
+    monitors: [...records.values()]
+      .map(cloneRecord)
+      .sort((left, right) => left.gitCommonDir.localeCompare(right.gitCommonDir)),
+  };
+  await fs.mkdir(path.dirname(statePath), { recursive: true });
+  await fs.writeFile(statePath, codec.encode(payload), "utf-8");
+}

package/src/mcp/monitor-tick-job.ts

@@ -0,0 +1,102 @@
+import { indexCommits } from "../warp/indexer.js";
+import { nodeGit } from "../adapters/node-git.js";
+import { openWarp } from "../warp/open.js";
+
+export interface MonitorTickWorkerJob {
+  readonly repoId: string;
+  readonly worktreeRoot: string;
+  readonly writerId: string;
+  readonly lastIndexedCommit: string | null;
+}
+
+export type MonitorTickWorkerResult =
+  | {
+    readonly ok: true;
+    readonly headAtStart: string | null;
+    readonly currentHead: string | null;
+    readonly lastIndexedCommit: string | null;
+    readonly backlogCommits: number;
+    readonly commitsIndexed: number;
+    readonly patchesWritten: number;
+  }
+  | {
+    readonly ok: false;
+    readonly error: string;
+    readonly currentHead: string | null;
+    readonly backlogCommits: number;
+  };
+
+async function readGit(cwd: string, args: readonly string[]): Promise<string | null> {
+  const result = await nodeGit.run({ cwd, args });
+  if (result.error !== undefined || result.status !== 0) {
+    return null;
+  }
+  const trimmed = result.stdout.trim();
+  return trimmed.length === 0 ? null : trimmed;
+}
+
+async function readHeadCommit(cwd: string): Promise<string | null> {
+  return readGit(cwd, ["rev-parse", "--verify", "HEAD"]);
+}
+
+async function countPendingCommits(
+  cwd: string,
+  from: string | null,
+  to: string | null,
+): Promise<number> {
+  if (to === null) return 0;
+  const range = from === null ? to : `${from}..${to}`;
+  const output = await readGit(cwd, ["rev-list", "--count", range]);
+  if (output === null) return 0;
+  const parsed = Number.parseInt(output, 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 0;
+}
+
+export async function runMonitorTickJob(job: MonitorTickWorkerJob): Promise<MonitorTickWorkerResult> {
+  const headAtStart = await readHeadCommit(job.worktreeRoot);
+
+  try {
+    const warp = await openWarp({
+      cwd: job.worktreeRoot,
+      writerId: job.writerId,
+    });
+    const result = await indexCommits(warp, {
+      cwd: job.worktreeRoot,
+      git: nodeGit,
+      ...(job.lastIndexedCommit !== null ? { from: job.lastIndexedCommit } : {}),
+      ...(headAtStart !== null ? { to: headAtStart } : {}),
+    });
+    if (!result.ok) {
+      throw new Error(result.error);
+    }
+    const currentHead = await readHeadCommit(job.worktreeRoot);
+    const lastIndexedCommit = headAtStart ?? job.lastIndexedCommit;
+    const backlogCommits = await countPendingCommits(
+      job.worktreeRoot,
+      lastIndexedCommit,
+      currentHead,
+    );
+    return {
+      ok: true,
+      headAtStart,
+      currentHead,
+      lastIndexedCommit,
+      backlogCommits,
+      commitsIndexed: result.commitsIndexed,
+      patchesWritten: result.patchesWritten,
+    };
+  } catch (error) {
+    const currentHead = await readHeadCommit(job.worktreeRoot);
+    const backlogCommits = await countPendingCommits(
+      job.worktreeRoot,
+      job.lastIndexedCommit,
+      currentHead,
+    );
+    return {
+      ok: false,
+      error: error instanceof Error ? error.message : String(error),
+      currentHead,
+      backlogCommits,
+    };
+  }
+}

package/src/mcp/monitor-types.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+import type { JsonCodec } from "../ports/codec.js";
+import type { FileSystem } from "../ports/filesystem.js";
+import type { GitClient } from "../ports/git.js";
+import type { DaemonJobScheduler } from "./daemon-job-scheduler.js";
+import type { DaemonWorkerPool } from "./daemon-worker-pool.js";
+import type { DaemonControlPlane } from "./daemon-control-plane.js";
+import type { WorkspaceBindRequest } from "./workspace-router.js";
+
+// ── Constants ──────────────────────────────────────────────────────
+
+export const CONTROL_PLANE_DIR = "control-plane";
+export const MONITORS_FILE = "monitors.json";
+export const DEFAULT_POLL_INTERVAL_MS = 5_000;
+
+// ── Lifecycle and health unions ────────────────────────────────────
+
+export type MonitorLifecycleState = "running" | "paused" | "stopped";
+export type MonitorHealth = "ok" | "lagging" | "error" | "unauthorized" | "paused" | "stopped";
+export type MonitorWorkerKind = "git_poll_indexer";
+export type MonitorAction = "start" | "pause" | "resume" | "stop";
+
+// ── Persistence schemas ────────────────────────────────────────────
+
+export const persistedMonitorSchema = z.object({
+  repoId: z.string(),
+  gitCommonDir: z.string(),
+  anchorWorktreeRoot: z.string(),
+  workerKind: z.literal("git_poll_indexer"),
+  lifecycleState: z.enum(["running", "paused", "stopped"]),
+  health: z.enum(["ok", "lagging", "error", "unauthorized", "paused", "stopped"]),
+  pollIntervalMs: z.number().int().positive(),
+  lastStartedAt: z.string().nullable(),
+  lastTickAt: z.string().nullable(),
+  lastSuccessAt: z.string().nullable(),
+  lastError: z.string().nullable(),
+  lastIndexedCommit: z.string().nullable(),
+  lastHeadCommit: z.string().nullable(),
+  backlogCommits: z.number().int().nonnegative(),
+  lastRunCommitsIndexed: z.number().int().nonnegative(),
+  lastRunPatchesWritten: z.number().int().nonnegative(),
+}).strict();
+
+export const persistedMonitorStateSchema = z.object({
+  version: z.literal(1),
+  monitors: z.array(persistedMonitorSchema),
+}).strict();
+
+export type PersistedMonitorRecord = z.infer<typeof persistedMonitorSchema>;
+export type PersistedMonitorState = z.infer<typeof persistedMonitorStateSchema>;
+
+// ── Timer entry ────────────────────────────────────────────────────
+
+export interface MonitorTimerEntry {
+  readonly timeout: ReturnType<typeof setTimeout>;
+}
+
+// ── Public view and result types ───────────────────────────────────
+
+export interface MonitorStatusView {
+  readonly repoId: string;
+  readonly gitCommonDir: string;
+  readonly anchorWorktreeRoot: string;
+  readonly authorizedWorkspaces: number;
+  readonly workerKind: MonitorWorkerKind;
+  readonly lifecycleState: MonitorLifecycleState;
+  readonly health: MonitorHealth;
+  readonly pollIntervalMs: number;
+  readonly lastStartedAt: string | null;
+  readonly lastTickAt: string | null;
+  readonly lastSuccessAt: string | null;
+  readonly lastError: string | null;
+  readonly lastIndexedCommit: string | null;
+  readonly lastHeadCommit: string | null;
+  readonly backlogCommits: number;
+  readonly lastRunCommitsIndexed: number;
+  readonly lastRunPatchesWritten: number;
+}
+
+export interface MonitorActionResult {
+  readonly ok: boolean;
+  readonly action: MonitorAction;
+  readonly created: boolean;
+  readonly changed: boolean;
+  readonly status?: MonitorStatusView;
+  readonly errorCode?: string;
+  readonly error?: string;
+}
+
+export interface MonitorStartRequest extends WorkspaceBindRequest {
+  readonly pollIntervalMs?: number | undefined;
+}
+
+export interface PersistentMonitorRuntimeOptions {
+  readonly fs: FileSystem;
+  readonly codec: JsonCodec;
+  readonly git: GitClient;
+  readonly graftDir: string;
+  readonly controlPlane: DaemonControlPlane;
+  readonly scheduler: DaemonJobScheduler;
+  readonly workerPool: DaemonWorkerPool;
+  readonly defaultPollIntervalMs?: number | undefined;
+}