@moretea-labs/forge 1.5.0-rc.1

package/src/cli/local-bridge/types.ts

@@ -0,0 +1,176 @@
+import type { ControllerAgent, TaskRisk } from "../controller/types";
+import type { ControllerCheckSnapshot } from "../controller/check-runner";
+import type { RepositoryCommandValue } from "../repositories/command-normalization";
+
+export type LocalBridgeApproval = "auto" | "confirm" | "manual-only";
+export type LocalExecutionPreference = "auto" | "workspace" | "worktree";
+export type LocalBridgeJobStatus =
+  | "pending_approval"
+  | "approved"
+  | "running"
+  | "dispatched"
+  | "succeeded"
+  | "timed_out"
+  | "orphaned"
+  | "stale"
+  | "failed"
+  | "cancelled";
+
+export type LocalBridgeJobAction =
+  | "launch-task"
+  | "quick-agent-session"
+  | "run-check"
+  | "verify-edit-session"
+  | "repository-command";
+
+export interface LaunchTaskPayload {
+  issueId: string;
+  taskId: string;
+  requestId?: string;
+  agent?: ControllerAgent;
+  isolate?: boolean;
+  executionMode?: LocalExecutionPreference;
+  timeoutMs?: number;
+  githubRepo?: string;
+  baseRef?: string;
+  model?: string;
+  createPullRequest?: boolean;
+  approveDestructive?: boolean;
+}
+
+export interface QuickAgentSessionPayload {
+  title: string;
+  objective: string;
+  requestId?: string;
+  summary?: string;
+  allowedPaths?: string[];
+  forbiddenPaths?: string[];
+  checks?: string[];
+  acceptanceCriteria?: string[];
+  risk?: TaskRisk;
+  agent?: Exclude<ControllerAgent, "github-copilot">;
+  isolate?: boolean;
+  executionMode?: LocalExecutionPreference;
+  timeoutMs?: number;
+  ephemeral?: boolean;
+  approveDestructive?: boolean;
+}
+
+export interface RunCheckPayload {
+  checkId: string;
+  requestId?: string;
+  timeoutMs?: number;
+  /** Immutable definition captured when the Job is accepted. */
+  checkSnapshot?: ControllerCheckSnapshot;
+}
+
+export interface VerifyEditSessionPayload {
+  sessionId: string;
+  revision: number;
+  requestId?: string;
+  checkIds?: string[];
+  reviewer?: string;
+  note?: string;
+}
+
+export interface RepositoryCommandPayload {
+  controllerHome: string;
+  repoId: string;
+  checkoutId?: string;
+  requestId?: string;
+  command: RepositoryCommandValue;
+  cwd?: string;
+  approvalToken?: string;
+  approvalRequestId?: string;
+  timeoutMs?: number;
+  maxOutputBytes?: number;
+}
+
+export type LocalBridgeJobPayload =
+  | LaunchTaskPayload
+  | QuickAgentSessionPayload
+  | RunCheckPayload
+  | VerifyEditSessionPayload
+  | RepositoryCommandPayload;
+
+export interface LocalBridgeJobRequest {
+  action: LocalBridgeJobAction;
+  payload: LocalBridgeJobPayload;
+  requestedBy?: string;
+}
+
+export interface LocalBridgeJobEvent {
+  at: string;
+  type:
+    | "job_created"
+    | "job_approved"
+    | "job_started"
+    | "job_dispatched"
+    | "job_progress"
+    | "job_approval_required"
+    | "job_succeeded"
+    | "job_failed"
+    | "job_cancelled"
+    | "job_cleaned";
+  message?: string;
+  data?: Record<string, unknown>;
+}
+
+export interface LocalBridgeJobOutcome {
+  /** Optional semantic classification; acceptance failures are not infrastructure failures. */
+  failureClass?: "acceptance_failure" | "infrastructure_failure";
+  acceptanceFailure?: { code: string; message: string };
+  process?: {
+    exitCode?: number | null;
+    timedOut?: boolean;
+    stdoutPath?: string;
+    stderrPath?: string;
+  };
+  policy?: {
+    decision: "allowed" | "approval_required" | "rejected";
+    repositoryChanged?: boolean;
+    changedPaths?: string[];
+  };
+  infrastructureError?: { code: string; message: string };
+}
+
+export interface LocalBridgeJob {
+  schemaVersion: 1;
+  jobId: string;
+  action: LocalBridgeJobAction;
+  payload: LocalBridgeJobPayload;
+  requestedBy: string;
+  approval: LocalBridgeApproval;
+  status: LocalBridgeJobStatus;
+  createdAt: string;
+  updatedAt: string;
+  approvedAt?: string;
+  startedAt?: string;
+  finishedAt?: string;
+  runId?: string;
+  issueId?: string;
+  taskId?: string;
+  result?: Record<string, unknown>;
+  /** Structured process/policy outcome. `error` is retained for compatibility. */
+  outcome?: LocalBridgeJobOutcome;
+  error?: string;
+  revision?: string;
+  ownerPid?: number;
+  workerPid?: number;
+  deadlineAt?: string;
+  heartbeatAt?: string;
+  ephemeral?: boolean;
+  cleanupAt?: string;
+}
+
+export interface LocalBridgeConfig {
+  version: 1;
+  host?: string;
+  port?: number;
+  autoOpen?: boolean;
+  /** Allow only authenticated /mobile/intent requests on a wildcard/LAN bind. */
+  allowLanMobileIntents?: boolean;
+  approvals?: Partial<Record<LocalBridgeJobAction, LocalBridgeApproval>>;
+  defaultTimeoutMs?: number;
+  maxTimeoutMs?: number;
+}

package/src/cli/mcp/access-mode.ts

@@ -0,0 +1,132 @@
+import { existsSync } from 'fs';
+import {
+  loadMcpServiceLocalConfig,
+  mcpControllerHomeLocalConfigPath,
+  mcpLocalConfigPath,
+  type McpLocalConfig,
+  writeMcpServiceLocalConfig,
+} from './auth';
+import type { McpToolset } from './types';
+import {
+  migrateControllerToolsetConfig,
+  normalizeConfiguredMcpToolset,
+  resolveControllerToolsetSelection,
+} from './toolset-selection';
+import {
+  isAccessMode,
+  type AccessMode,
+} from '../../runtime/control-plane/governance/access-policy';
+
+export type ControllerAccessConfigSource =
+  | 'controller_home.access_mode'
+  | 'repo_local_fallback.access_mode'
+  | 'controller_home.legacy_toolset'
+  | 'repo_local_fallback.legacy_toolset'
+  | 'default';
+
+export interface ControllerAccessState {
+  configuredAccessMode: AccessMode;
+  effectiveAccessMode: AccessMode;
+  /** Selected schema profile; access mode never changes this value. */
+  effectiveToolset: McpToolset;
+  source: ControllerAccessConfigSource;
+  lastAppliedAt?: string;
+  exposureRevision: number;
+  configPathSource: 'controller_home' | 'repo_local_fallback' | 'default';
+  legacyToolset?: McpToolset;
+  schemaStableAcrossAccessModes: true;
+}
+
+export interface ResolveControllerAccessStateInput {
+  controllerHome: string;
+  repoRoot?: string;
+  toolsetOverride?: McpToolset;
+  toolsetLocked?: boolean;
+}
+
+export interface PersistControllerAccessModeResult {
+  configPath: string;
+  config: McpLocalConfig;
+  state: ControllerAccessState;
+}
+
+export function accessModeForLegacyToolset(toolset: McpToolset): AccessMode {
+  return toolset === 'core' ? 'request' : 'full_access';
+}
+
+/** Retained for compatibility only; access mode no longer changes schema. */
+export function legacyToolsetForAccessMode(_mode: AccessMode): McpToolset {
+  return 'core';
+}
+
+function configLocation(controllerHome: string, repoRoot?: string): 'controller_home' | 'repo_local_fallback' | 'default' {
+  if (existsSync(mcpControllerHomeLocalConfigPath(controllerHome))) return 'controller_home';
+  if (repoRoot && existsSync(mcpLocalConfigPath(repoRoot))) return 'repo_local_fallback';
+  return 'default';
+}
+
+function normalizedRevision(value: unknown): number {
+  if (typeof value !== 'number' || !Number.isFinite(value)) return 0;
+  return Math.max(0, Math.trunc(value));
+}
+
+export function resolveControllerAccessState(input: ResolveControllerAccessStateInput): ControllerAccessState {
+  const location = configLocation(input.controllerHome, input.repoRoot);
+  const config = loadMcpServiceLocalConfig(input.controllerHome, input.repoRoot);
+  const lastAppliedAt = typeof config?.accessModeUpdatedAt === 'string' && config.accessModeUpdatedAt.trim()
+    ? config.accessModeUpdatedAt
+    : undefined;
+  const exposureRevision = normalizedRevision(config?.accessModeRevision);
+  const rawLegacyToolset = normalizeConfiguredMcpToolset(config?.toolset);
+  const selectedToolset = resolveControllerToolsetSelection(config, input.toolsetOverride);
+  const configuredAccessMode = isAccessMode(config?.accessMode)
+    ? config.accessMode
+    : rawLegacyToolset
+      ? accessModeForLegacyToolset(rawLegacyToolset)
+      : 'full_access';
+  const source: ControllerAccessConfigSource = isAccessMode(config?.accessMode)
+    ? (location === 'controller_home' ? 'controller_home.access_mode' : 'repo_local_fallback.access_mode')
+    : rawLegacyToolset
+      ? (location === 'controller_home' ? 'controller_home.legacy_toolset' : 'repo_local_fallback.legacy_toolset')
+      : 'default';
+  return {
+    configuredAccessMode,
+    effectiveAccessMode: configuredAccessMode,
+    effectiveToolset: selectedToolset.toolset,
+    source,
+    lastAppliedAt,
+    exposureRevision,
+    configPathSource: location,
+    legacyToolset: rawLegacyToolset,
+    schemaStableAcrossAccessModes: true,
+  };
+}
+
+export function persistControllerAccessMode(
+  controllerHome: string,
+  mode: AccessMode,
+  repoRoot?: string,
+): PersistControllerAccessModeResult {
+  const existing = loadMcpServiceLocalConfig(controllerHome, repoRoot) ?? {};
+  const accessModeUpdatedAt = new Date().toISOString();
+  const accessModeRevision = normalizedRevision(existing.accessModeRevision) + 1;
+  const migratedToolset = migrateControllerToolsetConfig(existing);
+  const config: McpLocalConfig = {
+    ...existing,
+    version: Math.max(existing.version ?? 1, 2),
+    profile: existing.profile ?? 'controller',
+    accessMode: mode,
+    accessModeUpdatedAt,
+    accessModeRevision,
+    // Access changes preserve an explicit profile and migrate the old implicit
+    // Advanced label to Core; they never expand or shrink schema themselves.
+    toolset: migratedToolset.toolset,
+    toolsetExplicit: migratedToolset.toolsetExplicit,
+  };
+  const configPath = writeMcpServiceLocalConfig(controllerHome, config);
+  return {
+    configPath,
+    config,
+    state: resolveControllerAccessState({ controllerHome, repoRoot }),
+  };
+}

package/src/cli/mcp/access-tools.ts

@@ -0,0 +1,387 @@
+import {
+  accessModeDescriptor,
+  isAccessMode,
+  readRepositoryAccessPolicy,
+  writeRepositoryAccessPolicy,
+} from '../../runtime/control-plane/governance/access-policy';
+import {
+  persistControllerAccessMode,
+  resolveControllerAccessState,
+} from './access-mode';
+import type { MultiRepositoryMcpToolContext } from './multi-repository';
+import { loadRepositoryRegistry, resolveRepositorySelection } from '../repositories/registry';
+import type { CallToolResult, McpToolDefinition } from './tools';
+
+function definition(
+  name: string,
+  description: string,
+  properties: Record<string, unknown>,
+  required: string[] = [],
+  readOnlyHint = true,
+): McpToolDefinition {
+  return {
+    name,
+    description,
+    inputSchema: {
+      type: 'object',
+      properties,
+      ...(required.length ? { required } : {}),
+      additionalProperties: false,
+    },
+    annotations: {
+      readOnlyHint,
+      openWorldHint: false,
+      destructiveHint: false,
+    },
+  };
+}
+
+const repoId = { type: 'string', description: 'Stable repository id. Omit when exactly one repository is selected. Cannot be combined with all_repositories.' };
+
+export const accessToolDefinitions: McpToolDefinition[] = [
+  definition(
+    'rh_access',
+    'Always-exposed compatibility policy. Normal operations follow the host AI permission model; the MCP tool schema remains stable.',
+    {
+      operation: {
+        type: 'string',
+        enum: ['get', 'preview', 'set'],
+        description: 'Defaults to get.',
+      },
+      repo_id: repoId,
+      all_repositories: {
+        type: 'boolean',
+        description: 'When setting access, also update every enabled repository policy to the selected mode.',
+      },
+      mode: {
+        type: 'string',
+        enum: ['request', 'full_access'],
+        description: 'Target mode for preview or set.',
+      },
+      confirm_authorization: {
+        type: 'boolean',
+        description: 'Deprecated compatibility field. Normal mode changes use the host AI permission decision and do not require a second Forge confirmation.',
+      },
+      confirmation_text: {
+        type: 'string',
+        description: 'Optional compatibility confirmation text. Tool exposure never changes and no reconnect is required.',
+      },
+    },
+    [],
+    false,
+  ),
+  definition(
+    'repository_access_get',
+    'Read the Request or Full Access permission level for the selected repository.',
+    { repo_id: repoId },
+  ),
+  definition(
+    'repository_access_preview',
+    'Preview how Request or Full Access changes execution approval behavior. Tool discovery remains unchanged.',
+    {
+      repo_id: repoId,
+      all_repositories: {
+        type: 'boolean',
+        description: 'Preview the selected mode for every enabled repository policy.',
+      },
+      mode: {
+        type: 'string',
+        enum: ['request', 'full_access'],
+        description: 'Target access mode.',
+      },
+    },
+  ),
+  definition(
+    'repository_access_set',
+    'Set one or all enabled repository compatibility modes. Normal operations follow the host AI permission model; secrets, outside-repository paths, and destructive operations retain hard gates.',
+    {
+      repo_id: repoId,
+      all_repositories: {
+        type: 'boolean',
+        description: 'When true, apply the mode to every enabled registered repository. Cannot be combined with repo_id.',
+      },
+      mode: {
+        type: 'string',
+        enum: ['request', 'full_access'],
+        description: 'Request asks before elevated local effects. Full Access permits normal local repository work without repeated approval prompts.',
+      },
+      confirm_authorization: {
+        type: 'boolean',
+        description: 'Deprecated compatibility field. It is accepted but no longer required as a second authorization layer.',
+      },
+      confirmation_text: {
+        type: 'string',
+        description: 'Optional compatibility confirmation text; explicit confirm_authorization is sufficient.',
+      },
+    },
+    ['mode'],
+    false,
+  ),
+];
+
+export const accessToolNames = accessToolDefinitions.map((tool) => tool.name);
+
+function selected(ctx: MultiRepositoryMcpToolContext, args: Record<string, unknown>) {
+  return resolveRepositorySelection({
+    repoId: typeof args.repo_id === 'string' ? args.repo_id : undefined,
+    explicitPath: ctx.explicitRepository?.canonicalRoot,
+    controllerHome: ctx.controllerHome,
+    allowSoleRepository: true,
+  });
+}
+
+function result(value: Record<string, unknown>, isError = false): CallToolResult {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(value, null, 2) }],
+    structuredContent: value,
+    ...(isError ? { isError: true } : {}),
+  };
+}
+
+function accessToolGroups(_mode: 'request' | 'full_access'): string[] {
+  // Discovery is intentionally stable across modes. These are availability
+  // groups, not automatically-authorized effect groups.
+  return [
+    'status_and_readiness',
+    'repository_selection',
+    'approval_and_handoffs',
+    'access_control_plane',
+    'repository_reads',
+    'repository_writes_and_patches',
+    'commands_and_checks',
+    'git_and_branches',
+    'worktrees_and_task_runs',
+    'direct_edit_sessions',
+    'ios_xcode_and_simulator',
+    'screenshots_and_review_artifacts',
+  ];
+}
+
+function accessStatePayload(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  configured = resolveControllerAccessState({
+    controllerHome: ctx.controllerHome,
+    repoRoot: ctx.explicitRepository?.canonicalRoot,
+  }),
+  effective = resolveControllerAccessState({
+    controllerHome: ctx.controllerHome,
+    repoRoot: ctx.explicitRepository?.canonicalRoot,
+    toolsetOverride: ctx.toolset,
+    toolsetLocked: ctx.toolsetLocked,
+  }),
+) {
+  const repositoryPolicy = readRepositoryAccessPolicy(ctx.controllerHome, repository.repoId);
+  return {
+    configuredAccessMode: configured.configuredAccessMode,
+    effectiveAccessMode: effective.effectiveAccessMode,
+    effectiveToolset: effective.effectiveToolset,
+    exposureRevision: configured.exposureRevision,
+    lastAppliedAt: configured.lastAppliedAt,
+    source: effective.source,
+    reconnectRequired: false,
+    schemaRefreshRequired: false,
+    toolSchemaStable: true,
+    restartRequired: false,
+    repository: {
+      repoId: repository.repoId,
+      name: repository.displayName,
+    },
+    repositoryPolicy,
+    repositoryPolicyDescriptor: accessModeDescriptor(repositoryPolicy.mode),
+    toolGroups: accessToolGroups(effective.effectiveAccessMode),
+  };
+}
+
+function previewPayload(
+  ctx: MultiRepositoryMcpToolContext,
+  repository: ReturnType<typeof selected>,
+  mode: 'request' | 'full_access',
+  applyAll: boolean,
+) {
+  const currentConfigured = resolveControllerAccessState({
+    controllerHome: ctx.controllerHome,
+    repoRoot: ctx.explicitRepository?.canonicalRoot,
+  });
+  const currentEffective = resolveControllerAccessState({
+    controllerHome: ctx.controllerHome,
+    repoRoot: ctx.explicitRepository?.canonicalRoot,
+    toolsetOverride: ctx.toolset,
+    toolsetLocked: ctx.toolsetLocked,
+  });
+  const currentPolicy = readRepositoryAccessPolicy(ctx.controllerHome, repository.repoId);
+  const currentGroups = accessToolGroups(currentEffective.effectiveAccessMode);
+  const nextGroups = accessToolGroups(mode);
+  return {
+    current: {
+      ...accessStatePayload(ctx, repository, currentConfigured, currentEffective),
+      toolGroups: currentGroups,
+    },
+    target: {
+      configuredAccessMode: mode,
+      effectiveAccessMode: mode,
+      effectiveToolset: currentEffective.effectiveToolset,
+      exposureRevision: currentConfigured.exposureRevision + (currentConfigured.configuredAccessMode === mode ? 0 : 1),
+      source: 'controller_home.access_mode',
+      toolGroups: nextGroups,
+      repositoryPolicyMode: mode,
+      repositoryPolicyDescriptor: accessModeDescriptor(mode),
+    },
+    changes: {
+      modeChanged: currentConfigured.configuredAccessMode !== mode,
+      toolsetChanged: false,
+      repositoryPolicyWillChange: currentPolicy.mode !== mode,
+      addedToolGroups: nextGroups.filter((group) => !currentGroups.includes(group)),
+      removedToolGroups: currentGroups.filter((group) => !nextGroups.includes(group)),
+      scope: applyAll ? 'all_enabled_repositories' : 'repository',
+    },
+    reconnectRequired: false,
+    schemaRefreshRequired: false,
+    toolSchemaStable: true,
+    restartRequired: false,
+    warning: 'Access mode changes execution approval only. The selected Core/Advanced/Full schema remains unchanged without reconnecting.',
+  };
+}
+
+export function callAccessTool(
+  ctx: MultiRepositoryMcpToolContext,
+  name: string,
+  args: Record<string, unknown>,
+): CallToolResult | null {
+  if (!accessToolNames.includes(name)) return null;
+  try {
+    if (name === 'rh_access') {
+      const operation = args.operation === 'preview' || args.operation === 'set' ? args.operation : 'get';
+      const repository = selected(ctx, args);
+      if (operation === 'get') return result(accessStatePayload(ctx, repository));
+
+      const mode = args.mode;
+      if (!isAccessMode(mode)) {
+        return result({
+          error: {
+            code: 'ACCESS_MODE_INVALID',
+            message: 'mode must be request or full_access',
+          },
+        }, true);
+      }
+
+      const applyAll = args.all_repositories === true;
+      if (operation === 'preview') return result(previewPayload(ctx, repository, mode, applyAll));
+
+      const persisted = persistControllerAccessMode(ctx.controllerHome, mode, ctx.explicitRepository?.canonicalRoot);
+      if (applyAll) {
+        const repositories = loadRepositoryRegistry(ctx.controllerHome).repositories
+          .filter((entry) => entry.enabled !== false);
+        for (const entry of repositories) writeRepositoryAccessPolicy(ctx.controllerHome, entry.repoId, mode, 'user');
+      } else {
+        writeRepositoryAccessPolicy(ctx.controllerHome, repository.repoId, mode, 'user');
+      }
+      const configured = persisted.state;
+      const effective = resolveControllerAccessState({
+        controllerHome: ctx.controllerHome,
+        repoRoot: ctx.explicitRepository?.canonicalRoot,
+        toolsetOverride: ctx.toolset,
+        toolsetLocked: ctx.toolsetLocked,
+      });
+      return result({
+        ...accessStatePayload(ctx, repository, configured, effective),
+        updatedConfigPath: persisted.configPath,
+        scope: applyAll ? 'all_enabled_repositories' : 'repository',
+        warning: 'Access mode was saved. It affects new execution-policy snapshots immediately; no Connector reconnect or schema refresh is required.',
+      });
+    }
+
+    if (name === 'repository_access_get') {
+      const repository = selected(ctx, args);
+      const policy = readRepositoryAccessPolicy(ctx.controllerHome, repository.repoId);
+      return result({
+        repository: {
+          repoId: repository.repoId,
+          name: repository.displayName,
+        },
+        policy,
+        descriptor: accessModeDescriptor(policy.mode),
+        scope: 'repository',
+        storage: 'controllerHome',
+      });
+    }
+
+    if (name === 'repository_access_preview') {
+      const repository = selected(ctx, args);
+      const mode = isAccessMode(args.mode) ? args.mode : readRepositoryAccessPolicy(ctx.controllerHome, repository.repoId).mode;
+      return result(previewPayload(ctx, repository, mode, args.all_repositories === true));
+    }
+
+    const mode = args.mode;
+    if (!isAccessMode(mode)) {
+      return result({
+        error: {
+          code: 'ACCESS_MODE_INVALID',
+          message: 'mode must be request or full_access',
+        },
+      }, true);
+    }
+    const applyAll = args.all_repositories === true;
+    if (applyAll && typeof args.repo_id === 'string' && args.repo_id.trim()) {
+      return result({
+        error: {
+          code: 'ACCESS_MODE_SCOPE_INVALID',
+          message: 'repo_id cannot be combined with all_repositories.',
+        },
+      }, true);
+    }
+
+    if (applyAll) {
+      const repositories = loadRepositoryRegistry(ctx.controllerHome).repositories
+        .filter((repository) => repository.enabled !== false);
+      const updated = repositories.map((repository) => ({
+        repository: {
+          repoId: repository.repoId,
+          name: repository.displayName,
+        },
+        policy: writeRepositoryAccessPolicy(ctx.controllerHome, repository.repoId, mode, 'user'),
+      }));
+      return result({
+        mode,
+        descriptor: accessModeDescriptor(mode),
+        scope: 'all_enabled_repositories',
+        storage: 'controllerHome',
+        updatedCount: updated.length,
+        repositories: updated,
+        reconnectRequired: false,
+        schemaRefreshRequired: false,
+        toolSchemaStable: true,
+        warning: mode === 'full_access'
+          ? 'Host-managed mode is active for every enabled repository. Normal work, including ordinary remote writes, follows the host AI permission model; destructive actions, outside-repository paths, and raw secrets retain hard gates.'
+          : 'Compatibility mode is stored for every enabled repository. Normal work still follows the host AI permission model; hard safety gates are unchanged.',
+      });
+    }
+
+    const repository = selected(ctx, args);
+    const policy = writeRepositoryAccessPolicy(ctx.controllerHome, repository.repoId, mode, 'user');
+    return result({
+      repository: {
+        repoId: repository.repoId,
+        name: repository.displayName,
+      },
+      policy,
+      descriptor: accessModeDescriptor(policy.mode),
+      scope: 'repository',
+      storage: 'controllerHome',
+      reconnectRequired: false,
+      schemaRefreshRequired: false,
+      toolSchemaStable: true,
+      warning: mode === 'full_access'
+        ? 'Host-managed mode is active. Normal work, including ordinary remote writes, follows the host AI permission model; destructive actions, outside-repository paths, and raw secrets retain hard gates.'
+        : 'Compatibility mode is stored. Normal work still follows the host AI permission model; hard safety gates are unchanged.',
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return result({
+      error: {
+        code: message.includes(':') ? message.slice(0, message.indexOf(':')) : 'ACCESS_POLICY_FAILED',
+        message,
+      },
+    }, true);
+  }
+}