@flyingrobots/graft 0.7.0 → 0.7.1

package/src/mcp/daemon-control-plane.ts

@@ -1,310 +0,0 @@
-import type { DaemonSchedulerCounts } from "./daemon-job-scheduler.js";
-import { ZERO_SCHEDULER_COUNTS } from "./daemon-job-scheduler.js";
-import type { DaemonWorkerCounts } from "./daemon-worker-pool.js";
-import type { RuntimeCausalContext } from "./runtime-causal-context.js";
-import {
-  DEFAULT_DAEMON_CAPABILITY_PROFILE,
-  resolveWorkspaceRequest,
-  type ResolvedWorkspace,
-  type WorkspaceBindRequest,
-  type WorkspaceCapabilityProfile,
-  type WorkspaceStatus,
-} from "./workspace-router.js";
-
-import {
-  buildStatePath,
-  capabilityProfilesEqual,
-  cloneAuthorizedWorkspaceRecord,
-  cloneCapabilityProfile,
-  loadPersistedState,
-  persistState,
-  resolveCapabilityProfile,
-  sortByWorktreeRoot,
-} from "./control-plane/authz-storage.js";
-
-import {
-  readRuntimeCausalContext,
-  readWorkspaceStatus,
-  resolveSharedAttachSource,
-  toDaemonSessionView,
-} from "./control-plane/session-registry.js";
-
-import {
-  buildStatusView,
-  toAuthorizedWorkspaceView,
-  ZERO_MONITOR_COUNTS,
-} from "./control-plane/status-projection.js";
-
-// ---------------------------------------------------------------------------
-// Barrel re-exports — keep every public type available from this path
-// ---------------------------------------------------------------------------
-
-export type {
-  AuthorizedWorkspaceRecord,
-  AuthorizedWorkspaceView,
-  DaemonControlPlaneOptions,
-  DaemonMonitorCounts,
-  DaemonRuntimeDescriptor,
-  DaemonSessionView,
-  DaemonStatusView,
-  SharedAttachSource,
-  WorkspaceAuthorizeRequest,
-  WorkspaceAuthorizeResult,
-  WorkspaceRevokeResult,
-} from "./control-plane/types.js";
-
-import type {
-  AuthorizedWorkspaceRecord,
-  AuthorizedWorkspaceView,
-  DaemonControlPlaneOptions,
-  DaemonMonitorCounts,
-  DaemonRuntimeDescriptor,
-  DaemonSessionView,
-  DaemonStatusView,
-  RegisteredTransport,
-  SharedAttachSource,
-  WorkspaceAuthorizeRequest,
-  WorkspaceAuthorizeResult,
-  WorkspaceRevokeResult,
-} from "./control-plane/types.js";
-
-// ---------------------------------------------------------------------------
-// DaemonControlPlane
-// ---------------------------------------------------------------------------
-
-export class DaemonControlPlane {
-  private readonly statePath: string;
-  private readonly authorizedWorkspaces = new Map<string, AuthorizedWorkspaceRecord>();
-  private readonly transports = new Map<string, RegisteredTransport>();
-  private loadPromise: Promise<void> | null = null;
-
-  constructor(private readonly options: DaemonControlPlaneOptions) {
-    this.statePath = buildStatePath(options.graftDir);
-  }
-
-  initialize(): Promise<void> {
-    return this.ensureLoaded();
-  }
-
-  registerTransport(
-    sessionId: string,
-    getWorkspaceStatus: () => WorkspaceStatus,
-    getRuntimeCausalContext: () => RuntimeCausalContext | null,
-  ): void {
-    const now = new Date().toISOString();
-    this.transports.set(sessionId, {
-      sessionId,
-      startedAt: now,
-      lastActivityAt: now,
-      getWorkspaceStatus,
-      getRuntimeCausalContext,
-    });
-  }
-
-  touchTransport(sessionId: string): void {
-    const session = this.transports.get(sessionId);
-    if (session === undefined) return;
-    session.lastActivityAt = new Date().toISOString();
-  }
-
-  unregisterTransport(sessionId: string): void {
-    this.transports.delete(sessionId);
-  }
-
-  resolveSharedAttachSource(input: {
-    readonly sessionId: string;
-    readonly repoId: string;
-    readonly worktreeId: string;
-  }): SharedAttachSource | null {
-    return resolveSharedAttachSource(this.transports, input);
-  }
-
-  async authorizeWorkspace(request: WorkspaceAuthorizeRequest): Promise<WorkspaceAuthorizeResult> {
-    const resolved = await resolveWorkspaceRequest(this.options.git, request);
-    if ("code" in resolved) {
-      return {
-        ok: false,
-        changed: false,
-        errorCode: resolved.code,
-        error: resolved.message,
-      };
-    }
-
-    await this.ensureLoaded();
-    const current = this.authorizedWorkspaces.get(resolved.worktreeId);
-    const nextCapabilityProfile = resolveCapabilityProfile(
-      current?.capabilityProfile,
-      DEFAULT_DAEMON_CAPABILITY_PROFILE,
-      request.runCapture,
-    );
-    const next: AuthorizedWorkspaceRecord = {
-      ...resolved,
-      capabilityProfile: nextCapabilityProfile,
-      authorizedAt: current?.authorizedAt ?? new Date().toISOString(),
-      lastBoundAt: current?.lastBoundAt ?? null,
-    };
-    const changed = current === undefined
-      ? true
-      : current.repoId !== next.repoId
-        || current.worktreeRoot !== next.worktreeRoot
-        || current.gitCommonDir !== next.gitCommonDir
-        || !capabilityProfilesEqual(current.capabilityProfile, next.capabilityProfile);
-
-    this.authorizedWorkspaces.set(next.worktreeId, next);
-    await this.persist();
-    return {
-      ok: true,
-      changed,
-      authorization: toAuthorizedWorkspaceView(next, this.activeTransportsFor(next.worktreeId)),
-    };
-  }
-
-  async revokeWorkspace(request: WorkspaceBindRequest): Promise<WorkspaceRevokeResult> {
-    const resolved = await resolveWorkspaceRequest(this.options.git, request);
-    if ("code" in resolved) {
-      return {
-        ok: false,
-        revoked: false,
-        errorCode: resolved.code,
-        error: resolved.message,
-      };
-    }
-
-    await this.ensureLoaded();
-    const current = this.authorizedWorkspaces.get(resolved.worktreeId);
-    if (current === undefined) {
-      return {
-        ok: false,
-        revoked: false,
-        repoId: resolved.repoId,
-        worktreeId: resolved.worktreeId,
-        worktreeRoot: resolved.worktreeRoot,
-        activeSessions: this.activeTransportsFor(resolved.worktreeId),
-        errorCode: "WORKSPACE_NOT_AUTHORIZED",
-        error: `Workspace ${resolved.worktreeRoot} is not authorized.`,
-      };
-    }
-
-    this.authorizedWorkspaces.delete(resolved.worktreeId);
-    await this.persist();
-    return {
-      ok: true,
-      revoked: true,
-      repoId: current.repoId,
-      worktreeId: current.worktreeId,
-      worktreeRoot: current.worktreeRoot,
-      activeSessions: this.activeTransportsFor(current.worktreeId),
-    };
-  }
-
-  async getCapabilityProfile(resolved: ResolvedWorkspace): Promise<WorkspaceCapabilityProfile | null> {
-    await this.ensureLoaded();
-    const record = this.authorizedWorkspaces.get(resolved.worktreeId);
-    return record === undefined ? null : cloneCapabilityProfile(record.capabilityProfile);
-  }
-
-  async noteBound(resolved: ResolvedWorkspace): Promise<void> {
-    await this.ensureLoaded();
-    const current = this.authorizedWorkspaces.get(resolved.worktreeId);
-    if (current === undefined) return;
-    this.authorizedWorkspaces.set(resolved.worktreeId, {
-      ...current,
-      lastBoundAt: new Date().toISOString(),
-    });
-    await this.persist();
-  }
-
-  async listAuthorizedWorkspaces(): Promise<readonly AuthorizedWorkspaceView[]> {
-    await this.ensureLoaded();
-    return sortByWorktreeRoot([...this.authorizedWorkspaces.values()]).map((record) => {
-      return toAuthorizedWorkspaceView(record, this.activeTransportsFor(record.worktreeId));
-    });
-  }
-
-  async listAuthorizedWorkspaceRecords(): Promise<readonly AuthorizedWorkspaceRecord[]> {
-    await this.ensureLoaded();
-    return sortByWorktreeRoot([...this.authorizedWorkspaces.values()]).map(cloneAuthorizedWorkspaceRecord);
-  }
-
-  async getAuthorizedWorkspace(request: WorkspaceBindRequest): Promise<AuthorizedWorkspaceRecord | null> {
-    const resolved = await resolveWorkspaceRequest(this.options.git, request);
-    if ("code" in resolved) return null;
-    await this.ensureLoaded();
-    const record = this.authorizedWorkspaces.get(resolved.worktreeId);
-    return record === undefined ? null : cloneAuthorizedWorkspaceRecord(record);
-  }
-
-  async getAuthorizedWorkspaceForRepo(
-    repoId: string,
-    preferredWorktreeRoot?: string,
-  ): Promise<AuthorizedWorkspaceRecord | null> {
-    await this.ensureLoaded();
-    const matches = [...this.authorizedWorkspaces.values()].filter((record) => record.repoId === repoId);
-    if (matches.length === 0) return null;
-    if (preferredWorktreeRoot !== undefined) {
-      const preferred = matches.find((record) => record.worktreeRoot === preferredWorktreeRoot);
-      if (preferred !== undefined) {
-        return cloneAuthorizedWorkspaceRecord(preferred);
-      }
-    }
-    const [first] = sortByWorktreeRoot(matches);
-    if (first === undefined) return null;
-    return cloneAuthorizedWorkspaceRecord(first);
-  }
-
-  listTransports(): readonly DaemonSessionView[] {
-    return [...this.transports.values()]
-      .map((session) => toDaemonSessionView(session, readWorkspaceStatus, readRuntimeCausalContext))
-      .sort((left, right) => left.startedAt.localeCompare(right.startedAt));
-  }
-
-  getStatus(
-    runtime: DaemonRuntimeDescriptor,
-    monitorCounts: DaemonMonitorCounts = ZERO_MONITOR_COUNTS,
-    schedulerCounts: DaemonSchedulerCounts = ZERO_SCHEDULER_COUNTS,
-    workerCounts: DaemonWorkerCounts,
-  ): DaemonStatusView {
-    return buildStatusView(
-      runtime,
-      this.listTransports(),
-      this.authorizedWorkspaces,
-      DEFAULT_DAEMON_CAPABILITY_PROFILE,
-      monitorCounts,
-      schedulerCounts,
-      workerCounts,
-    );
-  }
-
-  private async ensureLoaded(): Promise<void> {
-    if (this.loadPromise !== null) {
-      await this.loadPromise;
-      return;
-    }
-
-    this.loadPromise = (async () => {
-      const decoded = await loadPersistedState(this.statePath, this.options.fs, this.options.codec);
-      if (decoded === null) return;
-      for (const record of decoded.workspaces) {
-        this.authorizedWorkspaces.set(record.worktreeId, {
-          repoId: record.repoId,
-          worktreeId: record.worktreeId,
-          worktreeRoot: record.worktreeRoot,
-          gitCommonDir: record.gitCommonDir,
-          capabilityProfile: cloneCapabilityProfile(record.capabilityProfile),
-          authorizedAt: record.authorizedAt,
-          lastBoundAt: record.lastBoundAt,
-        });
-      }
-    })();
-
-    await this.loadPromise;
-  }
-
-  private async persist(): Promise<void> {
-    await persistState(this.statePath, this.options.fs, this.options.codec, this.authorizedWorkspaces);
-  }
-
-  private activeTransportsFor(worktreeId: string): number {
-    return this.listTransports().filter((session) => session.worktreeId === worktreeId).length;
-  }
-}

package/src/mcp/daemon-job-scheduler.ts

@@ -1,279 +0,0 @@
-import * as crypto from "node:crypto";
-
-export type DaemonJobKind = "repo_tool" | "persistent_monitor";
-export type DaemonJobPriority = "interactive" | "background";
-export type DaemonJobState = "queued" | "running";
-
-export interface DaemonJobRequest {
-  readonly sessionId: string | null;
-  readonly sliceId: string | null;
-  readonly repoId: string;
-  readonly worktreeId: string | null;
-  readonly tool: string;
-  readonly kind: DaemonJobKind;
-  readonly priority: DaemonJobPriority;
-  readonly writerId: string;
-}
-
-export interface DaemonJobView extends DaemonJobRequest {
-  readonly jobId: string;
-  readonly state: DaemonJobState;
-  readonly enqueuedAt: string;
-  readonly startedAt: string | null;
-  readonly waitMs: number;
-}
-
-export interface DaemonSchedulerCounts {
-  readonly maxConcurrentJobs: number;
-  readonly activeJobs: number;
-  readonly queuedJobs: number;
-  readonly interactiveQueuedJobs: number;
-  readonly backgroundQueuedJobs: number;
-  readonly activeWriterLanes: number;
-  readonly queuedWriterLanes: number;
-  readonly completedJobs: number;
-  readonly failedJobs: number;
-  readonly longestQueuedWaitMs: number;
-}
-
-export interface DaemonJobSchedulerOptions {
-  readonly maxConcurrentJobs?: number | undefined;
-}
-
-interface ScheduledJob extends DaemonJobRequest {
-  readonly jobId: string;
-  readonly enqueuedAtMs: number;
-  readonly enqueuedAt: string;
-  startedAtMs: number | null;
-  startedAt: string | null;
-  readonly run: () => Promise<unknown>;
-  readonly resolve: (value: unknown) => void;
-  readonly reject: (reason?: unknown) => void;
-}
-
-const DEFAULT_MAX_CONCURRENT_JOBS = 2;
-
-export const ZERO_SCHEDULER_COUNTS: DaemonSchedulerCounts = Object.freeze({
-  maxConcurrentJobs: DEFAULT_MAX_CONCURRENT_JOBS,
-  activeJobs: 0,
-  queuedJobs: 0,
-  interactiveQueuedJobs: 0,
-  backgroundQueuedJobs: 0,
-  activeWriterLanes: 0,
-  queuedWriterLanes: 0,
-  completedJobs: 0,
-  failedJobs: 0,
-  longestQueuedWaitMs: 0,
-});
-
-function normalizeMaxConcurrentJobs(value: number | undefined): number {
-  if (value === undefined) return DEFAULT_MAX_CONCURRENT_JOBS;
-  const normalized = Math.trunc(value);
-  if (!Number.isFinite(normalized) || normalized <= 0) {
-    throw new Error("maxConcurrentJobs must be a positive integer");
-  }
-  return normalized;
-}
-
-function toIso(ms: number): string {
-  return new Date(ms).toISOString();
-}
-
-function compareLaneKeys(left: string, right: string): number {
-  return left.localeCompare(right);
-}
-
-function buildWriterLaneKey(job: Pick<DaemonJobRequest, "repoId" | "writerId">): string {
-  return `${job.repoId}:${job.writerId}`;
-}
-
-function toJobView(job: ScheduledJob, nowMs: number, state: DaemonJobState): DaemonJobView {
-  return {
-    jobId: job.jobId,
-    sessionId: job.sessionId,
-    sliceId: job.sliceId,
-    repoId: job.repoId,
-    worktreeId: job.worktreeId,
-    tool: job.tool,
-    kind: job.kind,
-    priority: job.priority,
-    writerId: job.writerId,
-    state,
-    enqueuedAt: job.enqueuedAt,
-    startedAt: job.startedAt,
-    waitMs: (job.startedAtMs ?? nowMs) - job.enqueuedAtMs,
-  };
-}
-
-export class DaemonJobScheduler {
-  private readonly maxConcurrentJobs: number;
-  private readonly interactiveQueues = new Map<string, ScheduledJob[]>();
-  private readonly backgroundQueues = new Map<string, ScheduledJob[]>();
-  private readonly running = new Map<string, ScheduledJob>();
-  private completedJobs = 0;
-  private failedJobs = 0;
-  private lastInteractiveLaneKey: string | null = null;
-  private lastBackgroundLaneKey: string | null = null;
-
-  constructor(options: DaemonJobSchedulerOptions = {}) {
-    this.maxConcurrentJobs = normalizeMaxConcurrentJobs(options.maxConcurrentJobs);
-  }
-
-  enqueue<T>(request: DaemonJobRequest, run: () => Promise<T>): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      const enqueuedAtMs = Date.now();
-      const job: ScheduledJob = {
-        ...request,
-        jobId: crypto.randomUUID(),
-        enqueuedAtMs,
-        enqueuedAt: toIso(enqueuedAtMs),
-        startedAtMs: null,
-        startedAt: null,
-        run: () => run(),
-        resolve: (value) => {
-          resolve(value as T);
-        },
-        reject,
-      };
-      this.enqueueJob(job);
-      this.dispatch();
-    });
-  }
-
-  getCounts(nowMs = Date.now()): DaemonSchedulerCounts {
-    const queuedJobs = this.listQueuedJobs();
-    const interactiveQueuedJobs = queuedJobs.filter((job) => job.priority === "interactive").length;
-    const backgroundQueuedJobs = queuedJobs.length - interactiveQueuedJobs;
-    const longestQueuedWaitMs = queuedJobs.reduce((maxWait, job) => {
-      return Math.max(maxWait, nowMs - job.enqueuedAtMs);
-    }, 0);
-
-    return {
-      maxConcurrentJobs: this.maxConcurrentJobs,
-      activeJobs: this.running.size,
-      queuedJobs: queuedJobs.length,
-      interactiveQueuedJobs,
-      backgroundQueuedJobs,
-      activeWriterLanes: new Set([...this.running.values()].map((job) => buildWriterLaneKey(job))).size,
-      queuedWriterLanes: new Set(queuedJobs.map((job) => buildWriterLaneKey(job))).size,
-      completedJobs: this.completedJobs,
-      failedJobs: this.failedJobs,
-      longestQueuedWaitMs,
-    };
-  }
-
-  listJobs(nowMs = Date.now()): readonly DaemonJobView[] {
-    const runningJobs = [...this.running.values()]
-      .map((job) => toJobView(job, nowMs, "running"))
-      .sort((left, right) => {
-        return (left.startedAt ?? left.enqueuedAt).localeCompare(right.startedAt ?? right.enqueuedAt);
-      });
-    const queuedJobs = this.listQueuedJobs()
-      .map((job) => toJobView(job, nowMs, "queued"))
-      .sort((left, right) => left.enqueuedAt.localeCompare(right.enqueuedAt));
-    return [...runningJobs, ...queuedJobs];
-  }
-
-  private enqueueJob(job: ScheduledJob): void {
-    const queues = this.getQueues(job.priority);
-    const laneKey = buildWriterLaneKey(job);
-    const queue = queues.get(laneKey) ?? [];
-    queue.push(job);
-    queues.set(laneKey, queue);
-  }
-
-  private dispatch(): void {
-    while (this.running.size < this.maxConcurrentJobs) {
-      const nextJob = this.takeNextJob();
-      if (nextJob === null) {
-        return;
-      }
-      this.startJob(nextJob);
-    }
-  }
-
-  private startJob(job: ScheduledJob): void {
-    const startedAtMs = Date.now();
-    job.startedAtMs = startedAtMs;
-    job.startedAt = toIso(startedAtMs);
-    this.running.set(job.jobId, job);
-
-    void Promise.resolve()
-      .then(() => job.run())
-      .then((value) => {
-        this.running.delete(job.jobId);
-        this.completedJobs++;
-        job.resolve(value);
-        this.dispatch();
-      })
-      .catch((error: unknown) => {
-        this.running.delete(job.jobId);
-        this.failedJobs++;
-        job.reject(error);
-        this.dispatch();
-      });
-  }
-
-  private takeNextJob(): ScheduledJob | null {
-    return this.takeNextJobForPriority("interactive") ?? this.takeNextJobForPriority("background");
-  }
-
-  private takeNextJobForPriority(priority: DaemonJobPriority): ScheduledJob | null {
-    const queues = this.getQueues(priority);
-    return this.takeNextJobFromQueues(queues, priority);
-  }
-
-  private takeNextJobFromQueues(
-    queues: Map<string, ScheduledJob[]>,
-    priority: DaemonJobPriority,
-  ): ScheduledJob | null {
-    const laneKeys = [...queues.entries()]
-      .filter(([laneKey, queue]) => {
-        return queue.length > 0 && !this.hasRunningLane(laneKey);
-      })
-      .map(([laneKey]) => laneKey)
-      .sort(compareLaneKeys);
-
-    if (laneKeys.length === 0) {
-      return null;
-    }
-
-    const lastLaneKey = priority === "interactive" ? this.lastInteractiveLaneKey : this.lastBackgroundLaneKey;
-    const lastIndex = lastLaneKey === null ? -1 : laneKeys.indexOf(lastLaneKey);
-    const startIndex = lastIndex >= 0 ? (lastIndex + 1) % laneKeys.length : 0;
-
-    for (let offset = 0; offset < laneKeys.length; offset++) {
-      const laneKey = laneKeys[(startIndex + offset) % laneKeys.length];
-      if (laneKey === undefined) continue;
-      const queue = queues.get(laneKey);
-      const job = queue?.shift();
-      if (job === undefined) continue;
-      if (queue?.length === 0) {
-        queues.delete(laneKey);
-      }
-      if (priority === "interactive") {
-        this.lastInteractiveLaneKey = laneKey;
-      } else {
-        this.lastBackgroundLaneKey = laneKey;
-      }
-      return job;
-    }
-
-    return null;
-  }
-
-  private listQueuedJobs(): ScheduledJob[] {
-    return [
-      ...this.interactiveQueues.values(),
-      ...this.backgroundQueues.values(),
-    ].flatMap((queue) => [...queue]);
-  }
-
-  private hasRunningLane(laneKey: string): boolean {
-    return [...this.running.values()].some((job) => buildWriterLaneKey(job) === laneKey);
-  }
-
-  private getQueues(priority: DaemonJobPriority): Map<string, ScheduledJob[]> {
-    return priority === "interactive" ? this.interactiveQueues : this.backgroundQueues;
-  }
-}

package/src/mcp/daemon-repos.ts

@@ -1,99 +0,0 @@
-import type {
-  AuthorizedWorkspaceRecord,
-  DaemonSessionView,
-} from "./daemon-control-plane.js";
-import type { MonitorStatusView } from "./persistent-monitor-runtime.js";
-
-import { buildResult, normalizeFilter, sortAuthorizedWorkspaces } from "./repo-overview/filter.js";
-import { toRepoView } from "./repo-overview/view-projection.js";
-
-// ---------------------------------------------------------------------------
-// Barrel re-exports — keep every public type available from this path
-// ---------------------------------------------------------------------------
-
-export type {
-  DaemonRepoFilter,
-  DaemonRepoListView,
-  DaemonRepoMonitorView,
-  DaemonRepoOverviewOptions,
-  DaemonRepoView,
-  DaemonRepoWorktreeView,
-} from "./repo-overview/types.js";
-
-import type {
-  DaemonRepoFilter,
-  DaemonRepoListView,
-  DaemonRepoOverviewOptions,
-} from "./repo-overview/types.js";
-
-// ---------------------------------------------------------------------------
-// DaemonRepoOverview
-// ---------------------------------------------------------------------------
-
-export class DaemonRepoOverview {
-  constructor(private readonly options: DaemonRepoOverviewOptions) {}
-
-  async list(filter: DaemonRepoFilter = {}): Promise<DaemonRepoListView> {
-    const normalizedFilter = normalizeFilter(filter);
-    const resolvedRepoId = await this.resolveRepoIdFilter(normalizedFilter);
-    if (normalizedFilter.cwd !== undefined && resolvedRepoId === null) {
-      return buildResult(normalizedFilter, []);
-    }
-
-    const repoIdFilter = resolvedRepoId ?? normalizedFilter.repoId;
-    const [authorizedWorkspaces, monitors] = await Promise.all([
-      this.options.controlPlane.listAuthorizedWorkspaceRecords(),
-      this.options.monitorRuntime.listStatuses(),
-    ]);
-    const sessions = this.options.controlPlane.listTransports();
-    const visibleWorkspaces = authorizedWorkspaces.filter((workspace) => {
-      return repoIdFilter === undefined || workspace.repoId === repoIdFilter;
-    });
-    if (visibleWorkspaces.length === 0) {
-      return buildResult(normalizedFilter, []);
-    }
-
-    const workspacesByRepo = new Map<string, AuthorizedWorkspaceRecord[]>();
-    for (const workspace of visibleWorkspaces) {
-      const bucket = workspacesByRepo.get(workspace.repoId) ?? [];
-      bucket.push(workspace);
-      workspacesByRepo.set(workspace.repoId, bucket);
-    }
-
-    const sessionsByRepo = new Map<string, DaemonSessionView[]>();
-    for (const session of sessions) {
-      if (session.repoId === null) continue;
-      if (repoIdFilter !== undefined && session.repoId !== repoIdFilter) continue;
-      const bucket = sessionsByRepo.get(session.repoId) ?? [];
-      bucket.push(session);
-      sessionsByRepo.set(session.repoId, bucket);
-    }
-
-    const monitorsByRepo = new Map<string, MonitorStatusView>();
-    for (const status of monitors) {
-      if (repoIdFilter !== undefined && status.repoId !== repoIdFilter) continue;
-      monitorsByRepo.set(status.repoId, status);
-    }
-
-    const repos = [...workspacesByRepo.entries()]
-      .map(([repoId, repoWorkspaces]) => {
-        const sortedWorkspaces = sortAuthorizedWorkspaces(repoWorkspaces);
-        const repoSessions = sessionsByRepo.get(repoId) ?? [];
-        const monitor = monitorsByRepo.get(repoId) ?? null;
-        return toRepoView(repoId, sortedWorkspaces, repoSessions, monitor);
-      })
-      .sort((left, right) => left.gitCommonDir.localeCompare(right.gitCommonDir));
-
-    return buildResult(normalizedFilter, repos);
-  }
-
-  private async resolveRepoIdFilter(filter: DaemonRepoFilter): Promise<string | null | undefined> {
-    if (filter.cwd === undefined) return undefined;
-    const workspace = await this.options.controlPlane.getAuthorizedWorkspace({ cwd: filter.cwd });
-    if (workspace === null) return null;
-    if (filter.repoId !== undefined && workspace.repoId !== filter.repoId) {
-      return null;
-    }
-    return workspace.repoId;
-  }
-}