@moretea-labs/forge 1.8.0 → 1.8.1

package/adapters/mcp/runtime-gateway/protected-computer-adapter.ts

@@ -1,6 +1,7 @@
 import { COMPUTER_CONSOLE_UNLOCK_CAPABILITY } from '../../../packages/protocols/computer/index';
 import {
   executeProtectedConsoleUnlockInvocation,
+  executeProtectedConsoleUnlockLifecycle,
   executeProtectedConsoleUnlockPreparation,
 } from '../../../src/runtime/plugins/computer-registration';
 import type { MultiRepositoryMcpToolContext } from '../multi-repository';
@@ -18,7 +19,7 @@ function protectedErrorCode(error: unknown): string {
   return /^([A-Z][A-Z0-9_]+)(?::|$)/.exec(message)?.[1] ?? 'COMPUTER_CONSOLE_UNLOCK_FAILED';
 }
 
-export { executeProtectedConsoleUnlockInvocation, executeProtectedConsoleUnlockPreparation };
+export { executeProtectedConsoleUnlockInvocation, executeProtectedConsoleUnlockLifecycle, executeProtectedConsoleUnlockPreparation };
 export type {
   ProtectedConsoleUnlockInvocationInput,
   ProtectedConsoleUnlockPreparationInput,
@@ -29,7 +30,13 @@ export async function callProtectedComputerAdapter(
   name: string,
   args: Record<string, unknown>,
 ): Promise<CallToolResult | undefined> {
-  if (name !== 'computer_console_unlock_prepare' && name !== 'computer_console_unlock') return undefined;
+  const lifecycleAction = {
+    computer_console_unlock_enroll: 'console_unlock_enroll',
+    computer_console_unlock_status: 'console_unlock_status',
+    computer_console_unlock_recover: 'console_unlock_recover',
+    computer_console_unlock_revoke: 'console_unlock_revoke',
+  }[name] as 'console_unlock_enroll' | 'console_unlock_status' | 'console_unlock_recover' | 'console_unlock_revoke' | undefined;
+  if (name !== 'computer_console_unlock_prepare' && name !== 'computer_console_unlock' && !lifecycleAction) return undefined;
   if (name === 'computer_console_unlock' && args.credential_handle === undefined && typeof args.credential === 'string') {
     if (args.credential === FROZEN_CLIENT_PREPARE_CARRIER) {
       name = 'computer_console_unlock_prepare';
@@ -47,9 +54,14 @@ export async function callProtectedComputerAdapter(
       }, true);
     }
   }
-  const action = name === 'computer_console_unlock_prepare' ? 'prepare_unlock_console' : 'unlock_console';
+  const action = lifecycleAction ?? (name === 'computer_console_unlock_prepare' ? 'prepare_unlock_console' : 'unlock_console');
   try {
-    const payload = name === 'computer_console_unlock_prepare'
+    const payload = lifecycleAction
+      ? await executeProtectedConsoleUnlockLifecycle(lifecycleAction, {
+          confirmAuthorization: args.confirm_authorization === true,
+          timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,
+        }, ctx.controllerHome)
+      : name === 'computer_console_unlock_prepare'
       ? await executeProtectedConsoleUnlockPreparation({
           confirmAuthorization: args.confirm_authorization === true,
           timeoutMs: typeof args.timeout_ms === 'number' ? args.timeout_ms : undefined,

package/adapters/mcp/runtime-gateway/recovery-adapter.ts

@@ -1,6 +1,7 @@
 import type { CallToolResult } from '../../../packages/protocols/mcp/tool-contract';
 import type { MultiRepositoryMcpToolContext } from '../multi-repository';
 import { listControllerChecks } from '../../../src/cli/controller/check-runner';
+import { listRepositories } from '../../../src/cli/repositories/registry';
 import { ensureRepositoryRuntimeStorage } from '../../../src/cli/repositories/runtime-storage';
 import { cachedGitIdentity } from '../../../src/cli/repository/inspector';
 import { inferLocalControllerProcess } from '../../../src/runtime/diagnostics/performance';
@@ -18,6 +19,7 @@ import {
   executeCapabilityRecoveryAction,
   executeRuntimeMaintenanceAction,
   RecoveryApplicationError,
+  listInstanceRecoveryAuditRecords,
   listRecoveryAuditRecords,
   previewRuntimeStorageRepair,
   applyRuntimeStorageRepair,
@@ -31,57 +33,63 @@ import {
   runtimeSourceSnapshotStatus,
 } from './status-inbox-adapter';
 import { result } from './result-adapter';
-import { selected } from './shared-adapter';
+import { selected, selectedOptional } from './shared-adapter';
 
 async function capabilityRecoveryInput(
   ctx: MultiRepositoryMcpToolContext,
-  repository: ReturnType<typeof selected>,
+  repository: ReturnType<typeof selected> | undefined,
   args: Record<string, unknown>,
 ) {
   const readiness = await controllerReadinessEvidence(ctx, repository);
-  const runtimeSnapshot = readRepositoryProjectionSnapshot(ctx.controllerHome, repository.repoId);
-  const localBridge = loadMcpRuntimeState(repository.canonicalRoot)?.localController;
-  const inferredLocalBridge = inferLocalControllerProcess(repository.canonicalRoot);
-  const contextProjectionSourceRevision = String(
-    runtimeSnapshot.projection.metadata?.contentRevision ?? runtimeSnapshot.projection.revision,
-  );
-  const contextGitIdentity = cachedGitIdentity(repository.canonicalRoot);
-  const contextSourceIdentity = {
-    repoId: repository.repoId,
-    checkoutId: repository.activeCheckoutId,
-    canonicalRoot: repository.canonicalRoot,
-    head: contextGitIdentity.head,
-    branch: contextGitIdentity.branch,
-    workingTreeFingerprint: contextGitIdentity.workingTreeFingerprint,
-    runtimeGeneration: runtimeSnapshot.projection.metadata?.producerGeneration,
-    sourceRevision: contextProjectionSourceRevision,
-    variant: 'summary' as const,
-    toolset: ctx.toolset,
-    profile: ctx.policy.profile,
-  };
-  const contextProjection = readControllerContextProjection(ctx.controllerHome, repository.repoId, {
-    sourceIdentity: contextSourceIdentity,
-  });
-  const contextProjectionStale = controllerContextProjectionNeedsRefresh(
-    contextProjection,
-    contextProjectionSourceRevision,
-    contextSourceIdentity,
-  );
+  const runtimeSnapshot = repository ? readRepositoryProjectionSnapshot(ctx.controllerHome, repository.repoId) : undefined;
+  const localBridge = repository ? loadMcpRuntimeState(repository.canonicalRoot)?.localController : undefined;
+  const inferredLocalBridge = repository ? inferLocalControllerProcess(repository.canonicalRoot) : undefined;
+  const contextProjectionSourceRevision = runtimeSnapshot
+    ? String(runtimeSnapshot.projection.metadata?.contentRevision ?? runtimeSnapshot.projection.revision)
+    : undefined;
+  const contextGitIdentity = repository ? cachedGitIdentity(repository.canonicalRoot) : undefined;
+  const contextSourceIdentity = repository && contextProjectionSourceRevision !== undefined
+    ? {
+        repoId: repository.repoId,
+        checkoutId: repository.activeCheckoutId,
+        canonicalRoot: repository.canonicalRoot,
+        head: contextGitIdentity?.head,
+        branch: contextGitIdentity?.branch,
+        workingTreeFingerprint: contextGitIdentity?.workingTreeFingerprint,
+        runtimeGeneration: runtimeSnapshot?.projection.metadata?.producerGeneration,
+        sourceRevision: contextProjectionSourceRevision,
+        variant: 'summary' as const,
+        toolset: ctx.toolset,
+        profile: ctx.policy.profile,
+      }
+    : undefined;
+  const contextProjection = repository && contextSourceIdentity
+    ? readControllerContextProjection(ctx.controllerHome, repository.repoId, { sourceIdentity: contextSourceIdentity })
+    : undefined;
+  const contextProjectionStale = repository && contextProjectionSourceRevision !== undefined && contextSourceIdentity
+    ? controllerContextProjectionNeedsRefresh(
+        contextProjection,
+        contextProjectionSourceRevision,
+        contextSourceIdentity,
+      )
+    : undefined;
   const recentErrors = Array.isArray(args.recent_errors) ? args.recent_errors.map(String) : [];
   const runtimeSource = runtimeSourceSnapshotStatus(readiness.daemon.source, ctx.runtimeSourceRoot);
   let runtimeStorageReady: boolean | undefined;
   let runtimeStorageWarnings: string[] = [];
-  try {
-    const runtimeStorage = ensureRepositoryRuntimeStorage(repository, ctx.controllerHome);
-    runtimeStorageReady = runtimeStorage.readyForExecution;
-    runtimeStorageWarnings = runtimeStorage.warnings;
-  } catch (error) {
-    runtimeStorageReady = false;
-    runtimeStorageWarnings = [error instanceof Error ? error.message : String(error)];
+  if (repository) {
+    try {
+      const runtimeStorage = ensureRepositoryRuntimeStorage(repository, ctx.controllerHome);
+      runtimeStorageReady = runtimeStorage.readyForExecution;
+      runtimeStorageWarnings = runtimeStorage.warnings;
+    } catch (error) {
+      runtimeStorageReady = false;
+      runtimeStorageWarnings = [error instanceof Error ? error.message : String(error)];
+    }
   }
-  const plugins = listAssistantPluginManifests(ctx.controllerHome, repository, { preferStored: true });
-  const localJobs = listLocalBridgeJobSnapshots(repository.canonicalRoot, 30);
-  const executionJobs = listExecutionJobs(ctx.controllerHome, repository.repoId, 30);
+  const plugins = repository ? listAssistantPluginManifests(ctx.controllerHome, repository, { preferStored: true }) : [];
+  const localJobs = repository ? listLocalBridgeJobSnapshots(repository.canonicalRoot, 30) : [];
+  const executionJobs = repository ? listExecutionJobs(ctx.controllerHome, repository.repoId, 30) : [];
   return {
     generatedAt: new Date().toISOString(),
     daemonStatus: readiness.daemon.status,
@@ -97,8 +105,9 @@ async function capabilityRecoveryInput(
     runtimeHealth: readiness.health,
     runtimeOperationalView: readiness.operationalView,
     connectorHealthy: undefined,
-    runtimeProjectionStale: runtimeSnapshot.stale,
-    runtimeProjectionPersisted: runtimeSnapshot.persisted,
+    ...(runtimeSnapshot
+      ? { runtimeProjectionStale: runtimeSnapshot.stale, runtimeProjectionPersisted: runtimeSnapshot.persisted }
+      : {}),
     runtimeSourceCoherence: {
       ready: !runtimeSource.restartRequired,
       code: runtimeSource.code,
@@ -107,14 +116,13 @@ async function capabilityRecoveryInput(
         ? formatRuntimeSourceDriftMessage(runtimeSource)
         : 'Runtime source snapshot matches the current Controller Runtime source.',
     },
-    contextProjectionStale,
+    ...(contextProjectionStale === undefined ? {} : { contextProjectionStale }),
     commandPreviewAvailable: args.command_preview_available === undefined ? true : args.command_preview_available === true,
     commandExecuteAvailable: args.command_execute_available === undefined ? true : args.command_execute_available === true,
     issueToolsAvailable: args.issue_tools_available === undefined ? true : args.issue_tools_available === true,
     jobToolsAvailable: args.job_tools_available === undefined ? true : args.job_tools_available === true,
-    checksAvailable: listControllerChecks(repository.canonicalRoot).length > 0,
-    runtimeStorageReady,
-    runtimeStorageWarnings,
+    ...(repository ? { checksAvailable: listControllerChecks(repository.canonicalRoot).length > 0 } : {}),
+    ...(runtimeStorageReady === undefined ? {} : { runtimeStorageReady, runtimeStorageWarnings }),
     pluginStates: plugins.map((plugin) => ({
       pluginId: plugin.pluginId,
       enabled: plugin.enabled,
@@ -136,7 +144,7 @@ async function capabilityRecoveryInput(
 
 async function capabilityRecoverySnapshot(
   ctx: MultiRepositoryMcpToolContext,
-  repository: ReturnType<typeof selected>,
+  repository: ReturnType<typeof selected> | undefined,
   args: Record<string, unknown>,
 ): Promise<Record<string, unknown>> {
   return buildCapabilityRecoverySnapshot(await capabilityRecoveryInput(ctx, repository, args)) as unknown as Record<string, unknown>;
@@ -149,7 +157,7 @@ export async function callRecoveryAdapter(
 ): Promise<CallToolResult | undefined> {
   switch (name) {
     case 'capability_recovery_probe': {
-      const repository = selected(ctx, args);
+      const repository = selectedOptional(ctx, args);
       const snapshot = await buildCapabilityRecoverySnapshot(await capabilityRecoveryInput(ctx, repository, args));
       const blockingCapabilityCount = snapshot.capabilities
         .filter((capability) => ['blocked', 'unavailable', 'degraded'].includes(capability.state))
@@ -158,11 +166,16 @@ export async function callRecoveryAdapter(
       return result({
         ready,
         reasonCodes: ready ? [] : [snapshot.externalLifecycleHandoff?.reasonCode ?? 'RUNTIME_DIAGNOSTICS_ATTENTION_REQUIRED'],
+        // Instance-level diagnostics stay honest about missing repository context
+        // instead of silently attributing repository-scoped facts to the host.
+        repositoryContext: repository ? { repoId: repository.repoId, checkoutId: repository.activeCheckoutId } : null,
         diagnostics: {
           capabilityCount: snapshot.capabilities.length,
           blockingCapabilityCount,
           platformBlocked: snapshot.platformBlocked === true,
-          recentAuditCount: listRecoveryAuditRecords(ctx.controllerHome, repository.repoId, 10).length,
+          recentAuditCount: repository
+            ? listRecoveryAuditRecords(ctx.controllerHome, repository.repoId, 10).length
+            : listInstanceRecoveryAuditRecords(ctx.controllerHome, 10).length,
         },
         externalLifecycleHandoff: snapshot.externalLifecycleHandoff,
         observedAt: snapshot.generatedAt,
@@ -171,7 +184,7 @@ export async function callRecoveryAdapter(
       });
     }
     case 'capability_recovery_plan': {
-      const repository = selected(ctx, args);
+      const repository = selectedOptional(ctx, args);
       const snapshot = await buildCapabilityRecoverySnapshot(await capabilityRecoveryInput(ctx, repository, args));
       const blockingCapabilityCount = snapshot.capabilities
         .filter((capability) => ['blocked', 'unavailable', 'degraded'].includes(capability.state))
@@ -180,6 +193,7 @@ export async function callRecoveryAdapter(
       return result({
         ready,
         reasonCodes: ready ? [] : [snapshot.externalLifecycleHandoff?.reasonCode ?? 'RUNTIME_DIAGNOSTICS_ATTENTION_REQUIRED'],
+        repositoryContext: repository ? { repoId: repository.repoId, checkoutId: repository.activeCheckoutId } : null,
         diagnostics: {
           capabilityCount: snapshot.capabilities.length,
           blockingCapabilityCount,
@@ -219,7 +233,7 @@ export async function callRecoveryAdapter(
       }) as unknown as Record<string, unknown>);
     }
     case 'capability_recovery_apply': {
-      const repository = selected(ctx, args);
+      const repository = selectedOptional(ctx, args);
       const actionId = String(args.action_id ?? '').trim();
       const reason = typeof args.reason === 'string' && args.reason.trim() ? args.reason.trim() : 'manual recovery action';
       try {
@@ -236,7 +250,10 @@ export async function callRecoveryAdapter(
           recoverySnapshot: () => capabilityRecoverySnapshot(ctx, repository, args),
         }) as unknown as Record<string, unknown>);
       } catch (error) {
-        if (error instanceof RecoveryApplicationError && error.code === 'RECOVERY_ACTION_UNKNOWN') {
+        if (error instanceof RecoveryApplicationError && (
+          error.code === 'RECOVERY_ACTION_UNKNOWN'
+          || error.code === 'RECOVERY_REPOSITORY_CONTEXT_REQUIRED'
+        )) {
           return result({ error: { code: error.code, message: error.actionId } }, true);
         }
         throw error;

package/adapters/mcp/runtime-gateway/repository-compat-adapter.ts

@@ -2,7 +2,6 @@ import type { McpToolDefinition, CallToolResult } from '../../../packages/protoc
 import type { MultiRepositoryMcpToolContext } from '../multi-repository';
 import { boundedPluginArtifactImageContent, jsonPreview, result, resultWithPluginArtifactImages } from './result-adapter';
 import { expectedRevision, repositoryRootForRepoId, selected, stringList } from './shared-adapter';
-import { completeReviewedDirectEditWorkAfterCommit, prepareReviewedDirectEditWorkCommit, type ReviewedDirectEditWorkCommitPlan } from '../../../src/runtime/control-plane/execution/direct-edit-work-completion';
 import { repositoryChangeVerify } from '../../../src/cli/controller/composite-operations';
 import {
   commitSelectedPaths,
@@ -36,44 +35,14 @@ export async function callRepositoryCompatibilityAdapter(ctx: MultiRepositoryMcp
             }
       case 'git_commit_paths': {
               const repository = selected(ctx, args);
-              let reviewedCommitPlan: ReviewedDirectEditWorkCommitPlan | undefined;
-              let committed;
-              try {
-                committed = commitSelectedPaths(ctx.controllerHome, repository, {
-                  paths: args.paths,
-                  message: args.message,
-                  beforeCommitGuard: ({ stagedPaths, currentHead }) => {
-                    reviewedCommitPlan = prepareReviewedDirectEditWorkCommit({
-                      controllerHome: ctx.controllerHome,
-                      repository,
-                      stagedPaths,
-                      currentHead,
-                    });
-                  },
-                });
-              } catch (error) {
-                return result({
-                  repoId: repository.repoId,
-                  checkoutId: repository.activeCheckoutId,
-                  error: {
-                    code: 'SELECTED_PATH_PRECOMMIT_GUARD_FAILED',
-                    message: error instanceof Error ? error.message : String(error),
-                  },
-                }, true);
-              }
-              const directEditWorkCompletion = !committed.error && committed.commit?.ok === true && reviewedCommitPlan
-                ? completeReviewedDirectEditWorkAfterCommit({
-                    controllerHome: ctx.controllerHome,
-                    repository,
-                    plan: reviewedCommitPlan,
-                    fallbackBranch: repository.defaultBranch || 'main',
-                  })
-                : undefined;
+              const committed = commitSelectedPaths(ctx.controllerHome, repository, {
+                paths: args.paths,
+                message: args.message,
+              });
               return result({
                 repoId: repository.repoId,
                 checkoutId: repository.activeCheckoutId,
                 ...committed,
-                ...(directEditWorkCompletion ? { directEditWorkCompletion } : {}),
               }, Boolean(committed.error));
             }
       case 'repository_change_verify': {

package/adapters/mcp/runtime-gateway/result-adapter.ts

@@ -2,7 +2,7 @@ import { existsSync, readFileSync, statSync } from 'fs';
 import { isAbsolute, relative, resolve, sep } from 'path';
 import type { CallToolResult as SdkCallToolResult } from "@modelcontextprotocol/client";
 import type { CallToolResult } from '../../../packages/protocols/mcp/tool-contract';
-import { repositoryControllerRoot } from '../../../src/cli/repositories/controller-home';
+import { CONTROLLER_SCOPE_REPO_ID, FORGE_INSTANCE_SCOPE_KEY, controllerSystemRoot, repositoryControllerRoot } from '../../../src/cli/repositories/controller-home';
 import { redactMcpText } from '../redaction';
 
 /** Transport-only MCP result envelope. No lifecycle or domain mutation belongs here. */
@@ -34,7 +34,10 @@ export function boundedPluginArtifactImageContent(
     ...(nestedResult && Array.isArray(nestedResult.artifactCandidates) ? nestedResult.artifactCandidates : []),
   ];
   if (candidates.length === 0) return [];
-  const allowedRoot = resolve(repositoryControllerRoot(controllerHome, repoId));
+  const instanceScoped = repoId === FORGE_INSTANCE_SCOPE_KEY || repoId === CONTROLLER_SCOPE_REPO_ID;
+  const allowedRoots = instanceScoped
+    ? [resolve(controllerSystemRoot(controllerHome)), resolve(repositoryControllerRoot(controllerHome, CONTROLLER_SCOPE_REPO_ID))]
+    : [resolve(repositoryControllerRoot(controllerHome, repoId))];
   const images: McpImageContent[] = [];
   const seenPaths = new Set<string>();
 
@@ -48,8 +51,11 @@ export function boundedPluginArtifactImageContent(
 
     const resolvedPath = resolve(path);
     if (seenPaths.has(resolvedPath)) continue;
-    const rel = relative(allowedRoot, resolvedPath);
-    if (rel === '..' || rel.startsWith(`..${sep}`) || isAbsolute(rel)) continue;
+    const contained = allowedRoots.some((allowedRoot) => {
+      const rel = relative(allowedRoot, resolvedPath);
+      return rel !== '..' && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+    });
+    if (!contained) continue;
     if (!existsSync(resolvedPath)) continue;
 
     try {