@flyingrobots/graft 0.7.0 → 0.7.1

package/src/mcp/tools/workspace-bind.ts

@@ -1,25 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceBindTool: ToolDefinition = {
-  name: "workspace_bind",
-  description:
-    "Bind the current daemon session to a workspace by resolving repo and worktree identity server-side.",
-  schema: {
-    cwd: z.string(),
-    worktreeRoot: z.string().optional(),
-    gitCommonDir: z.string().optional(),
-    repoId: z.string().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const result = await ctx.bindWorkspace({
-        cwd: args["cwd"] as string,
-        worktreeRoot: args["worktreeRoot"] as string | undefined,
-        gitCommonDir: args["gitCommonDir"] as string | undefined,
-        repoId: args["repoId"] as string | undefined,
-      }, "workspace_bind");
-      return ctx.respond("workspace_bind", { ...result });
-    };
-  },
-};

package/src/mcp/tools/workspace-rebind.ts

@@ -1,25 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceRebindTool: ToolDefinition = {
-  name: "workspace_rebind",
-  description:
-    "Rebind the current daemon session to a different workspace and start a fresh session-local slice.",
-  schema: {
-    cwd: z.string(),
-    worktreeRoot: z.string().optional(),
-    gitCommonDir: z.string().optional(),
-    repoId: z.string().optional(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      const result = await ctx.rebindWorkspace({
-        cwd: args["cwd"] as string,
-        worktreeRoot: args["worktreeRoot"] as string | undefined,
-        gitCommonDir: args["gitCommonDir"] as string | undefined,
-        repoId: args["repoId"] as string | undefined,
-      }, "workspace_rebind");
-      return ctx.respond("workspace_rebind", { ...result });
-    };
-  },
-};

package/src/mcp/tools/workspace-revoke.ts

@@ -1,18 +0,0 @@
-import { z } from "zod";
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceRevokeTool: ToolDefinition = {
-  name: "workspace_revoke",
-  description:
-    "Revoke daemon authorization for a workspace while leaving any already-open sessions visible to the control plane.",
-  schema: {
-    cwd: z.string(),
-  },
-  createHandler(): ToolHandler {
-    return async (args, ctx) => {
-      return ctx.respond("workspace_revoke", { ...await ctx.revokeWorkspace({
-        cwd: args["cwd"] as string,
-      }) });
-    };
-  },
-};

package/src/mcp/tools/workspace-status.ts

@@ -1,12 +0,0 @@
-import type { ToolDefinition, ToolHandler } from "../context.js";
-
-export const workspaceStatusTool: ToolDefinition = {
-  name: "workspace_status",
-  description:
-    "Return the current daemon workspace binding state and resolved capability profile.",
-  createHandler(): ToolHandler {
-    return (_args, ctx) => {
-      return ctx.respond("workspace_status", { ...ctx.getWorkspaceStatus() });
-    };
-  },
-};

package/src/mcp/warp-pool.ts

@@ -1,36 +0,0 @@
-import type WarpApp from "@git-stunts/git-warp";
-import { DEFAULT_WARP_WRITER_ID } from "../warp/writer-id.js";
-
-export interface WarpPool {
-  getOrOpen(repoId: string, worktreeRoot: string, writerId?: string): Promise<WarpApp>;
-  size(): number;
-}
-
-export class InMemoryWarpPool implements WarpPool {
-  private readonly opened = new Map<string, Map<string, Promise<WarpApp>>>();
-
-  constructor(private readonly openWarp: (worktreeRoot: string, writerId: string) => Promise<WarpApp>) {}
-
-  getOrOpen(repoId: string, worktreeRoot: string, writerId: string = DEFAULT_WARP_WRITER_ID): Promise<WarpApp> {
-    const repoHandles = this.opened.get(repoId);
-    const cached = repoHandles?.get(writerId);
-    if (cached !== undefined) return cached;
-
-    const nextRepoHandles = repoHandles ?? new Map<string, Promise<WarpApp>>();
-    const opened = this.openWarp(worktreeRoot, writerId).catch((error: unknown) => {
-      const current = this.opened.get(repoId);
-      current?.delete(writerId);
-      if (current?.size === 0) {
-        this.opened.delete(repoId);
-      }
-      throw error;
-    });
-    nextRepoHandles.set(writerId, opened);
-    this.opened.set(repoId, nextRepoHandles);
-    return opened;
-  }
-
-  size(): number {
-    return this.opened.size;
-  }
-}

package/src/mcp/workspace-read-observation-model.ts

@@ -1,48 +0,0 @@
-import { z } from "zod";
-import type { JsonObject } from "../contracts/json-object.js";
-
-export const attributedReadArgsSchema = z.object({
-  path: z.string(),
-}).catchall(z.unknown());
-
-const safeReadObservationResultSchema = z.object({
-  projection: z.enum(["content", "outline", "cache_hit", "diff"]),
-  reason: z.string().optional(),
-}).catchall(z.unknown());
-
-const fileOutlineObservationResultSchema = z.object({
-  reason: z.string().optional(),
-  error: z.string().optional(),
-}).catchall(z.unknown());
-
-const readRangeObservationResultSchema = z.object({
-  content: z.string(),
-  startLine: z.number().int(),
-  endLine: z.number().int(),
-  reason: z.string().optional(),
-}).catchall(z.unknown());
-
-export type AttributedReadArgs = z.infer<typeof attributedReadArgsSchema>;
-export type SafeReadObservationResult = z.infer<typeof safeReadObservationResultSchema>;
-export type FileOutlineObservationResult = z.infer<typeof fileOutlineObservationResultSchema>;
-export type ReadRangeObservationResult = z.infer<typeof readRangeObservationResultSchema>;
-
-export function parseAttributedReadArgs(args: JsonObject): AttributedReadArgs | null {
-  const parsed = attributedReadArgsSchema.safeParse(args);
-  return parsed.success ? parsed.data : null;
-}
-
-export function parseSafeReadObservationResult(result: JsonObject): SafeReadObservationResult | null {
-  const parsed = safeReadObservationResultSchema.safeParse(result);
-  return parsed.success ? parsed.data : null;
-}
-
-export function parseFileOutlineObservationResult(result: JsonObject): FileOutlineObservationResult | null {
-  const parsed = fileOutlineObservationResultSchema.safeParse(result);
-  return parsed.success ? parsed.data : null;
-}
-
-export function parseReadRangeObservationResult(result: JsonObject): ReadRangeObservationResult | null {
-  const parsed = readRangeObservationResultSchema.safeParse(result);
-  return parsed.success ? parsed.data : null;
-}

package/src/mcp/workspace-read-observation.ts

@@ -1,103 +0,0 @@
-import * as path from "node:path";
-import type { JsonObject } from "../contracts/json-object.js";
-import type { WorkspaceExecutionContext } from "./workspace-router-model.js";
-import {
-  parseAttributedReadArgs,
-  parseFileOutlineObservationResult,
-  parseReadRangeObservationResult,
-  parseSafeReadObservationResult,
-} from "./workspace-read-observation-model.js";
-
-export type AttributedReadToolName = "safe_read" | "file_outline" | "read_range";
-
-export function buildWorkspaceReadObservation(
-  execution: WorkspaceExecutionContext,
-  toolName: AttributedReadToolName,
-  args: JsonObject,
-  result: JsonObject,
-): {
-  readonly surface: string;
-  readonly projection: string;
-  readonly sourceLayer: "canonical_structural_truth" | "workspace_overlay";
-  readonly reason: string;
-  readonly footprint: {
-    readonly paths: string[];
-    readonly symbols: string[];
-    readonly regions: {
-      readonly path: string;
-      readonly startLine: number;
-      readonly endLine: number;
-    }[];
-  };
-} | null {
-  const parsedArgs = parseAttributedReadArgs(args);
-  if (parsedArgs === null) {
-    return null;
-  }
-
-  const absolutePath = execution.resolvePath(parsedArgs.path);
-  const relativePath = path.relative(execution.worktreeRoot, absolutePath);
-  const footprintPath = relativePath.startsWith("..") ? absolutePath : relativePath;
-  const sourceLayer = execution.repoState.getState().workspaceOverlayId === null
-    ? "canonical_structural_truth"
-    : "workspace_overlay";
-
-  if (toolName === "safe_read") {
-    const parsedResult = parseSafeReadObservationResult(result);
-    if (parsedResult === null) {
-      return null;
-    }
-    return {
-      surface: "safe_read",
-      projection: parsedResult.projection,
-      sourceLayer,
-      reason: parsedResult.reason ?? "SAFE_READ",
-      footprint: {
-        paths: [footprintPath],
-        symbols: [],
-        regions: [],
-      },
-    };
-  }
-
-  if (toolName === "file_outline") {
-    const parsedResult = parseFileOutlineObservationResult(result);
-    if (parsedResult === null) {
-      return null;
-    }
-    if (typeof parsedResult.error === "string" || parsedResult.reason === "UNSUPPORTED_LANGUAGE") {
-      return null;
-    }
-    return {
-      surface: "file_outline",
-      projection: "outline",
-      sourceLayer,
-      reason: parsedResult.reason ?? "FILE_OUTLINE",
-      footprint: {
-        paths: [footprintPath],
-        symbols: [],
-        regions: [],
-      },
-    };
-  }
-
-  const parsedResult = parseReadRangeObservationResult(result);
-  if (parsedResult === null) {
-    return null;
-  }
-  return {
-    surface: "read_range",
-    projection: "content",
-    sourceLayer,
-    reason: parsedResult.reason ?? "READ_RANGE",
-    footprint: {
-      paths: [footprintPath],
-      symbols: [],
-      regions: [{
-        path: footprintPath,
-        startLine: parsedResult.startLine,
-        endLine: parsedResult.endLine,
-      }],
-    },
-  };
-}

package/src/mcp/workspace-router-capability.ts

@@ -1,32 +0,0 @@
-// ---------------------------------------------------------------------------
-// workspace-router-capability — capability profile resolution for binding
-//
-// Determines which capability profile applies when a workspace is bound,
-// whether in repo_local mode (always the local profile) or daemon mode
-// (delegated to the authorization policy).
-// ---------------------------------------------------------------------------
-import {
-  DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE,
-  type ResolvedWorkspace,
-  type WorkspaceAuthorizationPolicy,
-  type WorkspaceCapabilityProfile,
-  type WorkspaceMode,
-} from "./workspace-router-model.js";
-
-/**
- * Resolve the capability profile for a workspace binding attempt.
- *
- * In `repo_local` mode the default local profile is always returned.
- * In `daemon` mode the authorization policy is consulted; `null` means
- * the workspace is not authorized.
- */
-export async function resolveCapabilityProfile(input: {
-  readonly mode: WorkspaceMode;
-  readonly resolved: ResolvedWorkspace;
-  readonly authorizationPolicy?: WorkspaceAuthorizationPolicy | undefined;
-}): Promise<WorkspaceCapabilityProfile | null> {
-  if (input.mode === "repo_local") {
-    return DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE;
-  }
-  return (await input.authorizationPolicy?.getCapabilityProfile(input.resolved)) ?? null;
-}

package/src/mcp/workspace-router-history.ts

@@ -1,233 +0,0 @@
-// ---------------------------------------------------------------------------
-// workspace-router-history — persisted local history query operations
-//
-// Pure functions that query and observe persisted local history state.
-// Extracted from WorkspaceRouter to separate history concerns from
-// workspace lifecycle orchestration.
-// ---------------------------------------------------------------------------
-import { buildRuntimeStagedTarget } from "./runtime-staged-target.js";
-import {
-  buildWorkspaceReadObservation,
-  type AttributedReadToolName,
-} from "./workspace-read-observation.js";
-import type {
-  PersistedLocalActivityWindow,
-  PersistedLocalHistoryStore,
-  RepoConcurrencySummary,
-  PersistedLocalHistorySummary,
-  PersistedLocalHistoryContext,
-} from "./persisted-local-history.js";
-import type { PersistedLocalHistoryGraphContext } from "./persisted-local-history-graph.js";
-import type { RepoObservation } from "./repo-state.js";
-import type { RuntimeCausalContext } from "./runtime-causal-context.js";
-import type {
-  WorkspaceExecutionContext,
-  WorkspaceStatus,
-} from "./workspace-router-model.js";
-import type { JsonObject } from "../contracts/json-object.js";
-import type { BoundWorkspace } from "./workspace-router-runtime.js";
-
-// ---------------------------------------------------------------------------
-// Unbound fallback — returned when no workspace is bound
-// ---------------------------------------------------------------------------
-
-export const UNBOUND_PERSISTED_LOCAL_HISTORY_SUMMARY: PersistedLocalHistorySummary = Object.freeze({
-  availability: "none",
-  persistence: "persisted_local_history",
-  historyPath: null,
-  totalContinuityRecords: 0,
-  active: false,
-  lastOperation: null,
-  lastObservedAt: null,
-  continuityKey: null,
-  causalSessionId: null,
-  strandId: null,
-  checkoutEpochId: null,
-  continuedFromCausalSessionId: null,
-  continuityConfidence: "unknown",
-  continuityEvidence: [],
-  attribution: Object.freeze({
-    actor: Object.freeze({
-      actorId: "unknown",
-      actorKind: "unknown",
-      displayName: "Unknown",
-      source: "persisted_local_history.fallback",
-      authorityScope: "inferred",
-    }),
-    confidence: "unknown",
-    basis: "unknown_fallback",
-    evidence: [],
-  }),
-  latestReadEvent: null,
-  latestStageEvent: null,
-  latestTransitionEvent: null,
-  preserves: Object.freeze([
-    "continuity_operations",
-    "read_events",
-    "stage_events",
-    "transition_events",
-    "runtime_context_ids",
-    "workspace_overlay_snapshots",
-  ]),
-  excludes: Object.freeze([
-    "raw_chat_transcripts",
-    "queue_bookkeeping",
-    "canonical_provenance",
-    "canonical_structural_truth",
-  ]),
-  nextAction: "bind_workspace_to_begin_local_history",
-} as PersistedLocalHistorySummary);
-
-export const UNBOUND_PERSISTED_LOCAL_ACTIVITY_WINDOW = Object.freeze({
-  historyPath: null,
-  totalMatchingItems: 0,
-  truncated: false,
-  items: Object.freeze([]),
-});
-
-// ---------------------------------------------------------------------------
-// History query functions
-// ---------------------------------------------------------------------------
-
-/**
- * Retrieve the persisted local history summary for a bound workspace,
- * including side-effect observations for semantic transitions and staged targets.
- */
-export async function queryPersistedLocalHistorySummary(input: {
-  readonly persistedLocalHistory: PersistedLocalHistoryStore;
-  readonly binding: BoundWorkspace;
-  readonly status: WorkspaceStatus;
-  readonly buildCausalContext: (
-    binding: BoundWorkspace,
-    observation: { readonly checkoutEpoch: number },
-  ) => RuntimeCausalContext;
-  readonly buildHistoryContext: (
-    binding: BoundWorkspace,
-    observation: RepoObservation,
-  ) => PersistedLocalHistoryContext;
-  readonly buildGraphContext: (
-    binding: BoundWorkspace,
-  ) => Promise<PersistedLocalHistoryGraphContext | null>;
-}): Promise<PersistedLocalHistorySummary> {
-  const { persistedLocalHistory, binding, status, buildCausalContext, buildHistoryContext, buildGraphContext } = input;
-  const repoState = binding.slice.repoState;
-  if (repoState === null) {
-    return UNBOUND_PERSISTED_LOCAL_HISTORY_SUMMARY;
-  }
-  const observation = repoState.getState();
-  const causalContext = buildCausalContext(binding, observation);
-  const graph = await buildGraphContext(binding);
-  let summary = await persistedLocalHistory.summarize(status, causalContext, graph);
-
-  if (observation.semanticTransition !== null) {
-    await persistedLocalHistory.noteSemanticTransitionObservation({
-      current: buildHistoryContext(binding, observation),
-      semanticTransition: observation.semanticTransition,
-      transition: observation.lastTransition,
-      attribution: summary.attribution,
-      graph,
-    });
-    summary = await persistedLocalHistory.summarize(status, causalContext, graph);
-  }
-
-  const stagedTarget = buildRuntimeStagedTarget(status, causalContext, observation, summary.attribution);
-
-  if (stagedTarget.availability === "full_file") {
-    await persistedLocalHistory.noteStageObservation({
-      current: buildHistoryContext(binding, observation),
-      stagedTarget,
-      attribution: summary.attribution,
-      graph,
-    });
-    return persistedLocalHistory.summarize(status, causalContext, graph);
-  }
-
-  return summary;
-}
-
-/**
- * Retrieve the repo concurrency summary for a bound workspace.
- */
-export async function queryRepoConcurrencySummary(input: {
-  readonly persistedLocalHistory: PersistedLocalHistoryStore;
-  readonly status: WorkspaceStatus;
-  readonly buildGraphContext: (
-    binding: BoundWorkspace,
-  ) => Promise<PersistedLocalHistoryGraphContext | null>;
-  readonly binding: BoundWorkspace;
-}): Promise<RepoConcurrencySummary | null> {
-  return input.persistedLocalHistory.summarizeRepoConcurrency(
-    input.status,
-    await input.buildGraphContext(input.binding),
-  );
-}
-
-/**
- * Retrieve the persisted local activity window for a bound workspace.
- */
-export async function queryPersistedLocalActivityWindow(input: {
-  readonly persistedLocalHistory: PersistedLocalHistoryStore;
-  readonly binding: BoundWorkspace;
-  readonly status: WorkspaceStatus;
-  readonly limit: number;
-  readonly buildCausalContext: (
-    binding: BoundWorkspace,
-    observation: { readonly checkoutEpoch: number },
-  ) => RuntimeCausalContext;
-  readonly buildGraphContext: (
-    binding: BoundWorkspace,
-  ) => Promise<PersistedLocalHistoryGraphContext | null>;
-  readonly refreshSummary: () => Promise<void>;
-}): Promise<PersistedLocalActivityWindow> {
-  const { persistedLocalHistory, binding, status, limit, buildCausalContext, buildGraphContext, refreshSummary } = input;
-  const repoState = binding.slice.repoState;
-  if (repoState === null) {
-    return { ...UNBOUND_PERSISTED_LOCAL_ACTIVITY_WINDOW, limit } as PersistedLocalActivityWindow;
-  }
-  await refreshSummary();
-  const observation = repoState.getState();
-  const causalContext = buildCausalContext(binding, observation);
-  const graph = await buildGraphContext(binding);
-  return persistedLocalHistory.listRecentActivity(status, causalContext, limit, graph);
-}
-
-/**
- * Record a read observation against persisted local history.
- */
-export async function noteReadObservation(input: {
-  readonly persistedLocalHistory: PersistedLocalHistoryStore;
-  readonly execution: WorkspaceExecutionContext;
-  readonly toolName: AttributedReadToolName;
-  readonly args: JsonObject;
-  readonly result: JsonObject;
-  readonly buildHistoryContextFromExecution: (
-    execution: WorkspaceExecutionContext,
-    observation: RepoObservation,
-  ) => PersistedLocalHistoryContext;
-  readonly buildGraphContextFromExecution: (
-    execution: WorkspaceExecutionContext,
-  ) => Promise<PersistedLocalHistoryGraphContext | null>;
-}): Promise<void> {
-  const {
-    persistedLocalHistory, execution, toolName, args, result,
-    buildHistoryContextFromExecution, buildGraphContextFromExecution,
-  } = input;
-
-  const readObservation = buildWorkspaceReadObservation(execution, toolName, args, result);
-  if (readObservation === null) {
-    return;
-  }
-
-  const summary = await persistedLocalHistory.summarize(
-    execution.status,
-    execution.getCausalContext(),
-    await buildGraphContextFromExecution(execution),
-  );
-
-  await persistedLocalHistory.noteReadObservation({
-    current: buildHistoryContextFromExecution(execution, execution.repoState.getState()),
-    attribution: summary.attribution,
-    graph: await buildGraphContextFromExecution(execution),
-    ...readObservation,
-  });
-}

package/src/mcp/workspace-router-model.ts

@@ -1,131 +0,0 @@
-import type { ObservationCache } from "./cache.js";
-import type { Metrics } from "./metrics.js";
-import type { RepoStateTracker } from "./repo-state.js";
-import type { RuntimeCausalContext } from "./runtime-causal-context.js";
-import type { PersistedLocalHistorySummary } from "./persisted-local-history.js";
-import type { GovernorTracker } from "../session/tracker.js";
-import type { WarpContext } from "../warp/context.js";
-
-export type WorkspaceMode = "repo_local" | "daemon";
-export type WorkspaceBindState = "bound" | "unbound";
-export type WorkspaceBindAction = "bind" | "rebind";
-
-export interface WorkspaceCapabilityProfile {
-  readonly boundedReads: boolean;
-  readonly structuralTools: boolean;
-  readonly precisionTools: boolean;
-  readonly stateBookmarks: boolean;
-  readonly runtimeLogs: "session_local_only";
-  readonly runCapture: boolean;
-}
-
-export interface WorkspaceStatus {
-  readonly sessionMode: WorkspaceMode;
-  readonly bindState: WorkspaceBindState;
-  readonly repoId: string | null;
-  readonly worktreeId: string | null;
-  readonly worktreeRoot: string | null;
-  readonly gitCommonDir: string | null;
-  readonly graftDir: string | null;
-  readonly capabilityProfile: WorkspaceCapabilityProfile | null;
-}
-
-export interface WorkspaceActionResult extends WorkspaceStatus {
-  readonly ok: boolean;
-  readonly action: WorkspaceBindAction;
-  readonly freshSessionSlice: boolean;
-  readonly errorCode?: string;
-  readonly error?: string;
-}
-
-export interface CausalAttachResult extends WorkspaceStatus {
-  readonly ok: boolean;
-  readonly action: "attach";
-  readonly persistedLocalHistory: PersistedLocalHistorySummary;
-  readonly errorCode?: string;
-  readonly error?: string;
-}
-
-export interface WorkspaceBindRequest {
-  readonly cwd: string;
-  readonly worktreeRoot?: string | undefined;
-  readonly gitCommonDir?: string | undefined;
-  readonly repoId?: string | undefined;
-}
-
-export class WorkspaceBindingRequiredError extends Error {
-  readonly code = "UNBOUND_WORKSPACE";
-
-  constructor(toolName: string) {
-    super(`Tool ${toolName} requires an active workspace binding. Call workspace_bind first.`);
-    this.name = "WorkspaceBindingRequiredError";
-  }
-}
-
-export class WorkspaceCapabilityDeniedError extends Error {
-  readonly code = "CAPABILITY_DENIED";
-
-  constructor(toolName: string) {
-    super(`Tool ${toolName} is not enabled in the daemon default capability profile.`);
-    this.name = "WorkspaceCapabilityDeniedError";
-  }
-}
-
-export interface WorkspaceExecutionContext {
-  readonly sliceId: string;
-  readonly repoId: string;
-  readonly worktreeId: string;
-  readonly projectRoot: string;
-  readonly worktreeRoot: string;
-  readonly gitCommonDir: string;
-  readonly graftignorePatterns: readonly string[];
-  readonly resolvePath: (input: string) => string;
-  readonly capabilityProfile: WorkspaceCapabilityProfile;
-  readonly warpWriterId: string;
-  getCausalContext(): RuntimeCausalContext;
-  readonly status: WorkspaceStatus;
-  readonly governor: GovernorTracker;
-  readonly cache: ObservationCache;
-  readonly metrics: Metrics;
-  readonly graftDir: string;
-  readonly repoState: RepoStateTracker;
-  readonly getWarp: () => Promise<WarpContext>;
-}
-
-export interface ResolvedWorkspace {
-  readonly repoId: string;
-  readonly worktreeId: string;
-  readonly worktreeRoot: string;
-  readonly gitCommonDir: string;
-}
-
-export interface WorkspaceAuthorizationPolicy {
-  getCapabilityProfile(resolved: ResolvedWorkspace): Promise<WorkspaceCapabilityProfile | null>;
-  noteBound(resolved: ResolvedWorkspace): Promise<void>;
-}
-
-export interface WorkspaceSharedAttachPolicy {
-  resolveSharedAttachSource(input: {
-    readonly sessionId: string;
-    readonly repoId: string;
-    readonly worktreeId: string;
-  }): import("./persisted-local-history.js").PersistedLocalHistorySharedAttachSource | null;
-}
-
-export const DEFAULT_DAEMON_CAPABILITY_PROFILE: WorkspaceCapabilityProfile = Object.freeze({
-  boundedReads: true,
-  structuralTools: true,
-  precisionTools: true,
-  stateBookmarks: true,
-  runtimeLogs: "session_local_only",
-  runCapture: false,
-});
-
-export const DEFAULT_REPO_LOCAL_CAPABILITY_PROFILE: WorkspaceCapabilityProfile = Object.freeze({
-  boundedReads: true,
-  structuralTools: true,
-  precisionTools: true,
-  stateBookmarks: true,
-  runtimeLogs: "session_local_only",
-  runCapture: true,
-});