@flyingrobots/graft 0.5.0 → 0.6.0

package/src/mcp/cached-file.ts

@@ -1,40 +1 @@
-import { extractOutlineForFile } from "../parser/outline.js";
-import { detectStructuredFormat } from "../parser/lang.js";
-import type { SupportedStructuredFormat } from "../parser/lang.js";
-import type { OutlineEntry, JumpEntry } from "../parser/types.js";
-import { hashContent } from "./cache.js";
-
-/**
- * Immutable snapshot of a file read. Built once from a single readFileSync,
- * shared by all consumers (cache, policy, outline extraction) to eliminate
- * TOCTOU races where the file changes between reads.
- */
-export class CachedFile {
-  /** @internal */
-  private readonly _brand = "CachedFile" as const;
-  readonly path: string;
-  readonly rawContent: string;
-  readonly hash: string;
-  readonly lang: SupportedStructuredFormat | null;
-  readonly supportsOutline: boolean;
-  readonly outline: readonly OutlineEntry[];
-  readonly jumpTable: readonly JumpEntry[];
-  readonly actual: { readonly lines: number; readonly bytes: number };
-
-  constructor(filePath: string, rawContent: string) {
-    this.path = filePath;
-    this.rawContent = rawContent;
-    this.hash = hashContent(rawContent);
-    this.actual = {
-      lines: rawContent.split("\n").length,
-      bytes: Buffer.byteLength(rawContent),
-    };
-    this.lang = detectStructuredFormat(filePath);
-    this.supportsOutline = this.lang !== null;
-    const result = extractOutlineForFile(filePath, rawContent);
-    this.outline = result?.entries ?? [];
-    this.jumpTable = result?.jumpTable ?? [];
-    Object.freeze(this.actual);
-    Object.freeze(this);
-  }
-}
+export { CachedFile } from "../operations/cached-file.js";

package/src/mcp/context.ts

@@ -2,19 +2,20 @@
 // ToolContext — shared dependencies injected into every tool handler
 // ---------------------------------------------------------------------------
 
+import * as fs from "node:fs";
 import * as path from "node:path";
 import type { ObservationCache } from "./cache.js";
 import type { Metrics } from "./metrics.js";
-import type { SessionTracker } from "../session/tracker.js";
+import type { GovernorTracker } from "../session/tracker.js";
 import type { McpToolResult } from "./receipt.js";
 import type { FileSystem } from "../ports/filesystem.js";
 import type { JsonCodec } from "../ports/codec.js";
 import type { ProcessRunner } from "../ports/process-runner.js";
 import type { GitClient } from "../ports/git.js";
-import type WarpApp from "@git-stunts/git-warp";
+import type { WarpHandle } from "../ports/warp.js";
 import type { RepoObservation } from "./repo-state.js";
 import type { RunCaptureConfig } from "./run-capture-config.js";
-import type { RuntimeObservabilityState } from "./runtime-observability.js";
+import type { RuntimeObservabilityState, ToolCallFootprintRegion } from "./runtime-observability.js";
 import type { RuntimeCausalContext } from "./runtime-causal-context.js";
 import type { RuntimeWorkspaceOverlayFooting } from "./runtime-workspace-overlay.js";
 import type {
@@ -50,21 +51,21 @@ import type {
 
 import type { z } from "zod";
 
-export type ToolHandler = (args: Record<string, unknown>) => McpToolResult | Promise<McpToolResult>;
+export type ToolHandler = (args: Record<string, unknown>, ctx: ToolContext) => McpToolResult | Promise<McpToolResult>;
 
 export interface ToolDefinition {
   readonly name: McpToolName;
   readonly description: string;
   readonly schema?: Record<string, z.ZodType>;
   readonly policyCheck?: boolean;
-  readonly createHandler: (ctx: ToolContext) => ToolHandler;
+  readonly createHandler: () => ToolHandler;
 }
 
 export interface ToolContext {
   readonly projectRoot: string;
   readonly graftDir: string;
   readonly graftignorePatterns: readonly string[];
-  readonly session: SessionTracker;
+  readonly governor: GovernorTracker;
   readonly cache: ObservationCache;
   readonly metrics: Metrics;
   readonly fs: FileSystem;
@@ -74,8 +75,13 @@ export interface ToolContext {
   readonly runCapture: RunCaptureConfig;
   readonly observability: RuntimeObservabilityState;
   respond(tool: McpToolName, data: Record<string, unknown>): McpToolResult;
+  recordFootprint(entry: {
+    readonly paths?: readonly string[];
+    readonly symbols?: readonly string[];
+    readonly regions?: readonly ToolCallFootprintRegion[];
+  }): void;
   resolvePath(relative: string): string;
-  getWarp(): Promise<WarpApp>;
+  getWarp(): Promise<WarpHandle>;
   getRepoState(): RepoObservation;
   getCausalContext(): RuntimeCausalContext;
   getWorkspaceOverlayFooting(): Promise<RuntimeWorkspaceOverlayFooting | null>;
@@ -101,17 +107,81 @@ export interface ToolContext {
 
 /**
  * Resolve a user-provided path against projectRoot with traversal guard.
- * Absolute paths pass through unchanged. Relative paths that escape the
- * project root via ".." are rejected.
+ * Both absolute and relative paths are confined to the project root.
+ * Symlinks are resolved before the confinement check to prevent escapes.
  */
 export function createPathResolver(projectRoot: string): (input: string) => string {
+  const normalizedRoot = path.resolve(projectRoot);
+
+  // Resolve the project root itself through symlinks for consistent comparison
+  let realProjectRoot: string;
+  try {
+    realProjectRoot = fs.realpathSync(normalizedRoot);
+  } catch {
+    realProjectRoot = normalizedRoot;
+  }
+
   return (input: string): string => {
-    if (path.isAbsolute(input)) return input;
-    const resolved = path.resolve(projectRoot, input);
-    const rel = path.relative(projectRoot, resolved);
-    if (rel.startsWith("..")) {
+    // Resolve: absolute paths are taken as-is, relative paths join to projectRoot
+    const resolved = path.isAbsolute(input)
+      ? path.resolve(input)
+      : path.resolve(normalizedRoot, input);
+
+    // Logical confinement check (catches ".." traversal without needing fs access)
+    const logicalRel = path.relative(normalizedRoot, resolved);
+    if (logicalRel.startsWith("..") || path.isAbsolute(logicalRel)) {
+      throw new Error(`Path traversal blocked: ${input}`);
+    }
+
+    // Resolve symlinks before a second confinement check to prevent symlink escapes
+    let real: string;
+    try {
+      real = fs.realpathSync(resolved);
+    } catch {
+      // Target doesn't exist yet — return the logical path (already passed confinement)
+      return resolved;
+    }
+
+    // Symlink confinement check: the real path must be within the real project root
+    const realRel = path.relative(realProjectRoot, real);
+    if (realRel.startsWith("..") || path.isAbsolute(realRel)) {
       throw new Error(`Path traversal blocked: ${input}`);
     }
     return resolved;
   };
 }
+
+/**
+ * Runtime guard: asserts that the supplied value satisfies the ToolContext
+ * shape.  Used at composition-root boundaries to catch wiring errors early.
+ */
+export function assertToolContext(value: unknown): asserts value is ToolContext {
+  if (value === null || typeof value !== "object") {
+    throw new Error("ToolContext must be an object");
+  }
+  const obj = value as Record<string, unknown>;
+
+  const ports = ["fs", "codec", "process", "git"] as const;
+  for (const port of ports) {
+    if (obj[port] === undefined || obj[port] === null) {
+      throw new Error(`ToolContext missing port: ${port}`);
+    }
+  }
+
+  const governanceProps = ["governor", "cache", "metrics"] as const;
+  for (const prop of governanceProps) {
+    if (obj[prop] === undefined || obj[prop] === null) {
+      throw new Error(`ToolContext missing governance property: ${prop}`);
+    }
+  }
+
+  const methods = ["respond", "resolvePath", "getWarp", "getRepoState", "getCausalContext", "getWorkspaceStatus"] as const;
+  for (const method of methods) {
+    if (obj[method] === undefined || obj[method] === null) {
+      throw new Error(`ToolContext missing method: ${method}`);
+    }
+    if (typeof obj[method] !== "function") {
+      throw new Error(`ToolContext missing method: ${method} (got ${typeof obj[method]})`);
+    }
+  }
+}

package/src/mcp/control-plane/authz-storage.ts

@@ -0,0 +1,129 @@
+import * as path from "node:path";
+import { z } from "zod";
+import type { JsonCodec } from "../../ports/codec.js";
+import type { FileSystem } from "../../ports/filesystem.js";
+import type {
+  WorkspaceCapabilityProfile,
+} from "../workspace-router.js";
+import type { AuthorizedWorkspaceRecord } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Zod schemas for persisted authorization state
+// ---------------------------------------------------------------------------
+
+const workspaceCapabilityProfileSchema = z.object({
+  boundedReads: z.boolean(),
+  structuralTools: z.boolean(),
+  precisionTools: z.boolean(),
+  stateBookmarks: z.boolean(),
+  runtimeLogs: z.literal("session_local_only"),
+  runCapture: z.boolean(),
+}).strict();
+
+const authorizedWorkspaceRecordSchema = z.object({
+  repoId: z.string(),
+  worktreeId: z.string(),
+  worktreeRoot: z.string(),
+  gitCommonDir: z.string(),
+  capabilityProfile: workspaceCapabilityProfileSchema,
+  authorizedAt: z.string(),
+  lastBoundAt: z.string().nullable(),
+}).strict();
+
+const persistedControlPlaneStateSchema = z.object({
+  version: z.literal(1),
+  workspaces: z.array(authorizedWorkspaceRecordSchema),
+}).strict();
+
+export type PersistedControlPlaneState = z.infer<typeof persistedControlPlaneStateSchema>;
+
+// ---------------------------------------------------------------------------
+// Capability profile helpers
+// ---------------------------------------------------------------------------
+
+export function cloneCapabilityProfile(
+  profile: WorkspaceCapabilityProfile,
+): WorkspaceCapabilityProfile {
+  return { ...profile };
+}
+
+export function capabilityProfilesEqual(
+  left: WorkspaceCapabilityProfile,
+  right: WorkspaceCapabilityProfile,
+): boolean {
+  return left.boundedReads === right.boundedReads
+    && left.structuralTools === right.structuralTools
+    && left.precisionTools === right.precisionTools
+    && left.stateBookmarks === right.stateBookmarks
+    && left.runCapture === right.runCapture;
+}
+
+export function resolveCapabilityProfile(
+  current: WorkspaceCapabilityProfile | undefined,
+  defaultProfile: WorkspaceCapabilityProfile,
+  runCapture: boolean | undefined,
+): WorkspaceCapabilityProfile {
+  return {
+    ...(current ?? defaultProfile),
+    ...(runCapture !== undefined ? { runCapture } : {}),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Record helpers
+// ---------------------------------------------------------------------------
+
+export function sortByWorktreeRoot(records: readonly AuthorizedWorkspaceRecord[]): AuthorizedWorkspaceRecord[] {
+  return [...records].sort((left, right) => left.worktreeRoot.localeCompare(right.worktreeRoot));
+}
+
+export function cloneAuthorizedWorkspaceRecord(record: AuthorizedWorkspaceRecord): AuthorizedWorkspaceRecord {
+  return {
+    ...record,
+    capabilityProfile: cloneCapabilityProfile(record.capabilityProfile),
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Persistence
+// ---------------------------------------------------------------------------
+
+const CONTROL_PLANE_DIR = "control-plane";
+const AUTHORIZED_WORKSPACES_FILE = "authorized-workspaces.json";
+
+export function buildStatePath(graftDir: string): string {
+  return path.join(
+    path.resolve(graftDir),
+    CONTROL_PLANE_DIR,
+    AUTHORIZED_WORKSPACES_FILE,
+  );
+}
+
+export async function loadPersistedState(
+  statePath: string,
+  fs: FileSystem,
+  codec: JsonCodec,
+): Promise<PersistedControlPlaneState | null> {
+  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 null;
+  return persistedControlPlaneStateSchema.parse(codec.decode(raw));
+}
+
+export async function persistState(
+  statePath: string,
+  fs: FileSystem,
+  codec: JsonCodec,
+  workspaces: ReadonlyMap<string, AuthorizedWorkspaceRecord>,
+): Promise<void> {
+  const payload: PersistedControlPlaneState = {
+    version: 1,
+    workspaces: sortByWorktreeRoot([...workspaces.values()]),
+  };
+  await fs.mkdir(path.dirname(statePath), { recursive: true });
+  await fs.writeFile(statePath, codec.encode(payload), "utf-8");
+}

package/src/mcp/control-plane/session-registry.ts

@@ -0,0 +1,115 @@
+import type { RuntimeCausalContext } from "../runtime-causal-context.js";
+import type { WorkspaceStatus } from "../workspace-router.js";
+import { cloneCapabilityProfile } from "./authz-storage.js";
+import type {
+  DaemonSessionView,
+  RegisteredTransport,
+  SharedAttachSource,
+} from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Session view projection
+// ---------------------------------------------------------------------------
+
+export function toDaemonSessionView(
+  session: RegisteredTransport,
+  readWorkspaceStatus: (s: RegisteredTransport) => WorkspaceStatus,
+  readRuntimeCausalContext: (s: RegisteredTransport) => RuntimeCausalContext | null,
+): DaemonSessionView {
+  const status = readWorkspaceStatus(session);
+  const causalContext = readRuntimeCausalContext(session);
+  return {
+    sessionId: session.sessionId,
+    sessionMode: "daemon",
+    bindState: status.bindState,
+    repoId: status.repoId,
+    worktreeId: status.worktreeId,
+    worktreeRoot: status.worktreeRoot,
+    causalSessionId: causalContext?.causalSessionId ?? null,
+    checkoutEpochId: causalContext?.checkoutEpochId ?? null,
+    capabilityProfile: status.capabilityProfile === null ? null : cloneCapabilityProfile(status.capabilityProfile),
+    startedAt: session.startedAt,
+    lastActivityAt: session.lastActivityAt,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Workspace status & causal context safe readers
+// ---------------------------------------------------------------------------
+
+export function readWorkspaceStatus(session: RegisteredTransport): WorkspaceStatus {
+  try {
+    return session.getWorkspaceStatus();
+  } catch {
+    return {
+      sessionMode: "daemon",
+      bindState: "unbound",
+      repoId: null,
+      worktreeId: null,
+      worktreeRoot: null,
+      gitCommonDir: null,
+      graftDir: null,
+      capabilityProfile: null,
+    };
+  }
+}
+
+export function readRuntimeCausalContext(session: RegisteredTransport): RuntimeCausalContext | null {
+  try {
+    return session.getRuntimeCausalContext();
+  } catch {
+    return null;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Shared attach resolution
+// ---------------------------------------------------------------------------
+
+export function resolveSharedAttachSource(
+  sessions: ReadonlyMap<string, RegisteredTransport>,
+  input: {
+    readonly sessionId: string;
+    readonly repoId: string;
+    readonly worktreeId: string;
+  },
+): SharedAttachSource | null {
+  const candidates = [...sessions.values()]
+    .filter((session) => session.sessionId !== input.sessionId)
+    .flatMap((session) => {
+      const status = readWorkspaceStatus(session);
+      if (
+        status.bindState !== "bound" ||
+        status.repoId !== input.repoId ||
+        status.worktreeId !== input.worktreeId
+      ) {
+        return [];
+      }
+      const causalContext = readRuntimeCausalContext(session);
+      if (causalContext === null) {
+        return [];
+      }
+      return [{
+        sourceSessionId: session.sessionId,
+        causalSessionId: causalContext.causalSessionId,
+        strandId: causalContext.strandId,
+        lastActivityAt: session.lastActivityAt,
+      }];
+    })
+    .sort((left, right) => right.lastActivityAt.localeCompare(left.lastActivityAt));
+
+  if (candidates.length !== 1) {
+    return null;
+  }
+
+  const [source] = candidates;
+  if (source === undefined) {
+    return null;
+  }
+
+  return {
+    sourceSessionId: source.sourceSessionId,
+    causalSessionId: source.causalSessionId,
+    strandId: source.strandId,
+  };
+}

package/src/mcp/control-plane/status-projection.ts

@@ -0,0 +1,76 @@
+import type { DaemonSchedulerCounts } from "../daemon-job-scheduler.js";
+import type { DaemonWorkerCounts } from "../daemon-worker-pool.js";
+import type { WorkspaceCapabilityProfile } from "../workspace-router.js";
+import { cloneCapabilityProfile } from "./authz-storage.js";
+import type {
+  AuthorizedWorkspaceRecord,
+  AuthorizedWorkspaceView,
+  DaemonMonitorCounts,
+  DaemonRuntimeDescriptor,
+  DaemonSessionView,
+  DaemonStatusView,
+} from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Zero-value defaults
+// ---------------------------------------------------------------------------
+
+export const ZERO_MONITOR_COUNTS: DaemonMonitorCounts = Object.freeze({
+  totalMonitors: 0,
+  runningMonitors: 0,
+  pausedMonitors: 0,
+  stoppedMonitors: 0,
+  failingMonitors: 0,
+  backlogMonitors: 0,
+});
+
+// ---------------------------------------------------------------------------
+// Status view assembly
+// ---------------------------------------------------------------------------
+
+export function buildStatusView(
+  runtime: DaemonRuntimeDescriptor,
+  sessions: readonly DaemonSessionView[],
+  authorizedWorkspaces: ReadonlyMap<string, AuthorizedWorkspaceRecord>,
+  defaultCapabilityProfile: WorkspaceCapabilityProfile,
+  monitorCounts: DaemonMonitorCounts,
+  schedulerCounts: DaemonSchedulerCounts,
+  workerCounts: DaemonWorkerCounts,
+): DaemonStatusView {
+  const boundSessions = sessions.filter((session) => session.bindState === "bound").length;
+  return {
+    ok: true,
+    sessionMode: "daemon",
+    activeSessions: sessions.length,
+    boundSessions,
+    unboundSessions: sessions.length - boundSessions,
+    authorizedWorkspaces: authorizedWorkspaces.size,
+    authorizedRepos: new Set([...authorizedWorkspaces.values()].map((record) => record.repoId)).size,
+    workspaceBindRequiresAuthorization: true,
+    defaultCapabilityProfile: cloneCapabilityProfile(defaultCapabilityProfile),
+    totalMonitors: monitorCounts.totalMonitors,
+    runningMonitors: monitorCounts.runningMonitors,
+    pausedMonitors: monitorCounts.pausedMonitors,
+    stoppedMonitors: monitorCounts.stoppedMonitors,
+    failingMonitors: monitorCounts.failingMonitors,
+    backlogMonitors: monitorCounts.backlogMonitors,
+    scheduler: schedulerCounts,
+    workers: workerCounts,
+    ...runtime,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Authorized workspace view projection
+// ---------------------------------------------------------------------------
+
+export function toAuthorizedWorkspaceView(
+  record: AuthorizedWorkspaceRecord,
+  activeSessionCount: number,
+): AuthorizedWorkspaceView {
+  return {
+    ...record,
+    capabilityProfile: cloneCapabilityProfile(record.capabilityProfile),
+    activeSessions: activeSessionCount,
+  };
+}

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

@@ -0,0 +1,144 @@
+import type { DaemonSchedulerCounts } from "../daemon-job-scheduler.js";
+import type { DaemonWorkerCounts } from "../daemon-worker-pool.js";
+import type { RuntimeCausalContext } from "../runtime-causal-context.js";
+import type {
+  WorkspaceBindRequest,
+  WorkspaceCapabilityProfile,
+  WorkspaceStatus,
+} from "../workspace-router.js";
+
+// ---------------------------------------------------------------------------
+// Internal: session tracking
+// ---------------------------------------------------------------------------
+
+export interface RegisteredTransport {
+  readonly sessionId: string;
+  readonly startedAt: string;
+  readonly getWorkspaceStatus: () => WorkspaceStatus;
+  readonly getRuntimeCausalContext: () => RuntimeCausalContext | null;
+  lastActivityAt: string;
+}
+
+// ---------------------------------------------------------------------------
+// Authorization types
+// ---------------------------------------------------------------------------
+
+export interface AuthorizedWorkspaceRecord {
+  readonly repoId: string;
+  readonly worktreeId: string;
+  readonly worktreeRoot: string;
+  readonly gitCommonDir: string;
+  readonly capabilityProfile: WorkspaceCapabilityProfile;
+  readonly authorizedAt: string;
+  readonly lastBoundAt: string | null;
+}
+
+export interface AuthorizedWorkspaceView extends AuthorizedWorkspaceRecord {
+  readonly activeSessions: number;
+}
+
+export interface WorkspaceAuthorizeRequest extends WorkspaceBindRequest {
+  readonly runCapture?: boolean | undefined;
+}
+
+export interface WorkspaceAuthorizeResult {
+  readonly ok: boolean;
+  readonly changed: boolean;
+  readonly authorization?: AuthorizedWorkspaceView;
+  readonly errorCode?: string;
+  readonly error?: string;
+}
+
+export interface WorkspaceRevokeResult {
+  readonly ok: boolean;
+  readonly revoked: boolean;
+  readonly repoId?: string | null;
+  readonly worktreeId?: string | null;
+  readonly worktreeRoot?: string | null;
+  readonly activeSessions?: number;
+  readonly errorCode?: string;
+  readonly error?: string;
+}
+
+// ---------------------------------------------------------------------------
+// Session view
+// ---------------------------------------------------------------------------
+
+export interface DaemonSessionView {
+  readonly sessionId: string;
+  readonly sessionMode: "daemon";
+  readonly bindState: WorkspaceStatus["bindState"];
+  readonly repoId: string | null;
+  readonly worktreeId: string | null;
+  readonly worktreeRoot: string | null;
+  readonly causalSessionId: string | null;
+  readonly checkoutEpochId: string | null;
+  readonly capabilityProfile: WorkspaceCapabilityProfile | null;
+  readonly startedAt: string;
+  readonly lastActivityAt: string;
+}
+
+// ---------------------------------------------------------------------------
+// Daemon runtime & status projection
+// ---------------------------------------------------------------------------
+
+export interface DaemonRuntimeDescriptor {
+  readonly transport: "unix_socket" | "named_pipe";
+  readonly sameUserOnly: true;
+  readonly socketPath: string;
+  readonly mcpPath: string;
+  readonly healthPath: string;
+  readonly activeWarpRepos: number;
+  readonly startedAt: string;
+}
+
+export interface SharedAttachSource {
+  readonly sourceSessionId: string;
+  readonly causalSessionId: string;
+  readonly strandId: string;
+}
+
+export interface DaemonMonitorCounts {
+  readonly totalMonitors: number;
+  readonly runningMonitors: number;
+  readonly pausedMonitors: number;
+  readonly stoppedMonitors: number;
+  readonly failingMonitors: number;
+  readonly backlogMonitors: number;
+}
+
+export interface DaemonStatusView extends DaemonRuntimeDescriptor {
+  readonly ok: true;
+  readonly sessionMode: "daemon";
+  readonly activeSessions: number;
+  readonly boundSessions: number;
+  readonly unboundSessions: number;
+  readonly authorizedWorkspaces: number;
+  readonly authorizedRepos: number;
+  readonly workspaceBindRequiresAuthorization: true;
+  readonly defaultCapabilityProfile: WorkspaceCapabilityProfile;
+  readonly totalMonitors: number;
+  readonly runningMonitors: number;
+  readonly pausedMonitors: number;
+  readonly stoppedMonitors: number;
+  readonly failingMonitors: number;
+  readonly backlogMonitors: number;
+  readonly scheduler: DaemonSchedulerCounts;
+  readonly workers: DaemonWorkerCounts;
+}
+
+// ---------------------------------------------------------------------------
+// Control plane constructor options
+// ---------------------------------------------------------------------------
+
+export interface DaemonControlPlaneOptions {
+  readonly fs: FileSystem;
+  readonly codec: JsonCodec;
+  readonly git: GitClient;
+  readonly graftDir: string;
+}
+
+// Re-import port types so consumers don't need to reach into ports/
+import type { FileSystem } from "../../ports/filesystem.js";
+import type { JsonCodec } from "../../ports/codec.js";
+import type { GitClient } from "../../ports/git.js";