@moretea-labs/forge 1.7.0 → 1.7.1

package/src/cli/github/contracts.ts

@@ -0,0 +1,16 @@
+export interface GitHubRepositoryInfo {
+  nameWithOwner: string;
+  owner: string;
+  repo: string;
+  url: string;
+  defaultBranch: string;
+}
+
+export interface GitHubStatus {
+  available: boolean;
+  authenticated: boolean;
+  version?: string;
+  repository?: GitHubRepositoryInfo;
+  agentTaskSupported: boolean;
+  errors: string[];
+}

package/src/cli/github/github.ts

@@ -7,22 +7,8 @@ import type { ControllerIssue, ControllerTask, GitHubIssueLink } from '../contro
 import { readTaskRunEvidence } from '../controller/run-evidence';
 import { resolveEffectiveTaskState, resolveIssueLifecycleStatus } from '../controller/task-status-resolver';
 
-export interface GitHubRepositoryInfo {
-  nameWithOwner: string;
-  owner: string;
-  repo: string;
-  url: string;
-  defaultBranch: string;
-}
-
-export interface GitHubStatus {
-  available: boolean;
-  authenticated: boolean;
-  version?: string;
-  repository?: GitHubRepositoryInfo;
-  agentTaskSupported: boolean;
-  errors: string[];
-}
+export type { GitHubRepositoryInfo, GitHubStatus } from './contracts';
+import type { GitHubRepositoryInfo, GitHubStatus } from './contracts';
 
 export interface PublishIssueOptions {
   repo?: string;

package/src/cli/github/session.ts

@@ -6,7 +6,8 @@ import {
   classifyGitHubCopilotPreflight,
   executorHealthCode,
 } from '../agent-jobs/executor-health';
-import { getGitHubStatus, resolveGitHubRepository, type GitHubRepositoryInfo } from './github';
+import { getGitHubStatus, resolveGitHubRepository } from './github';
+import type { GitHubRepositoryInfo } from './contracts';
 
 export interface GitHubAgentSession {
   id: string;

package/src/cli/local-bridge/facade-api.ts

@@ -10,7 +10,7 @@ import {
   persistControllerAccessMode,
   resolveControllerAccessState,
 } from '../mcp/access-mode';
-import { listControllerChecks, runControllerCheck } from '../controller/check-runner';
+import { listControllerChecks } from '../controller/check-runner';
 import { createMcpToolContext, type MultiRepositoryMcpToolContext } from '../mcp/multi-repository';
 import { readSchedulerHealthSnapshot } from '../../runtime/control-plane/global-scheduler/scheduler';
 import { observeRuntimeStatus } from '../../runtime/root/status';
@@ -27,7 +27,6 @@ import {
   buildFacadeResult,
   buildSyncOperationDigest,
   classifyUserFacingError,
-  classifyVerificationOutcome,
   continueGoalWorkloop,
   delegateToCodexCerebellum,
   dismissHandoffItem,
@@ -44,7 +43,6 @@ import {
   stopGoalWorkloop,
   summarizeHandoffItem,
   summarizeWorkContract,
-  verifyGoalWorkloop,
   type ExecutionModeSelectionInput,
   type FacadeResult,
   type HandoffItem,
@@ -94,6 +92,7 @@ import type {
   WorkSummaryViewModel,
 } from './console-view-models';
 import { listActiveOccurrences, listSchedules } from '../../runtime/workflow/schedules/store';
+import { executeWorkVerification } from '../../runtime/control-plane/execution/work-verification-service';
 
 export type ConsoleFacadeContext = {
   controllerHome: string;
@@ -1042,6 +1041,9 @@ export function startConsoleWork(
     requiresApproval?: boolean;
     destructive?: boolean;
     accessMode?: AccessMode;
+    workspaceMode?: 'current' | 'isolated' | 'auto';
+    requireWorktree?: boolean;
+    directMainProhibited?: boolean;
     approvalConfirmed?: boolean;
     forceMode?: 'direct_control' | 'goal_workloop' | 'handoff_only';
     checkIds?: string[];
@@ -1061,7 +1063,17 @@ export function startConsoleWork(
       allowedPaths: input.allowedPaths,
       forbiddenPaths: input.forbiddenPaths,
       checks: input.checkIds,
-      constraints: input.accessMode ? { accessMode: input.accessMode } : undefined,
+      constraints: input.accessMode !== undefined
+        || input.workspaceMode !== undefined
+        || input.requireWorktree !== undefined
+        || input.directMainProhibited !== undefined
+        ? {
+            ...(input.accessMode !== undefined ? { accessMode: input.accessMode } : {}),
+            ...(input.workspaceMode !== undefined ? { workspaceMode: input.workspaceMode } : {}),
+            ...(input.requireWorktree !== undefined ? { requireWorktree: input.requireWorktree } : {}),
+            ...(input.directMainProhibited !== undefined ? { directMainProhibited: input.directMainProhibited } : {}),
+          }
+        : undefined,
       modeInput: {
         objective: input.objective,
         expectedFiles: input.expectedFiles,
@@ -1092,51 +1104,24 @@ export function continueConsoleWork(ctx: ConsoleFacadeContext, workId: string, n
   );
 }
 
-export function verifyConsoleWork(
+export async function verifyConsoleWork(
   ctx: ConsoleFacadeContext,
   input: { workId: string; checkId?: string; simulate?: boolean; checkFailed?: boolean; infrastructureFailed?: boolean },
-): FacadeResult {
-  const checks = listControllerChecks(ctx.repository.canonicalRoot);
-  const workloopCtx = {
-    workStore: store(ctx),
-    handoffStore: store(ctx),
-    repoId: ctx.repository.repoId,
-    availableChecks: checks,
-  };
-  const work = getWorkContract(store(ctx), input.workId);
-  const requested = input.checkId || work?.checks[0] || checks[0]?.id || '';
-  const classified = classifyVerificationOutcome({ checkId: requested, available: checks });
-  if (classified.outcome === 'invalid_check_id') {
-    return verifyGoalWorkloop(workloopCtx, { workId: input.workId, checkId: requested });
-  }
-  if (input.simulate) {
-    return verifyGoalWorkloop(workloopCtx, {
-      workId: input.workId,
-      checkId: classified.normalizedCheckId ?? requested,
-      checkFailed: input.checkFailed === true,
-      infrastructureFailed: input.infrastructureFailed === true,
-    });
-  }
-  try {
-    const executed = runControllerCheck(ctx.repository.canonicalRoot, classified.normalizedCheckId!);
-    return verifyGoalWorkloop(workloopCtx, {
-      workId: input.workId,
-      checkId: classified.normalizedCheckId!,
-      infrastructureFailed: executed.timedOut === true,
-      checkFailed: !executed.ok && !executed.timedOut,
-    });
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    const facade = verifyGoalWorkloop(workloopCtx, {
-      workId: input.workId,
-      checkId: classified.normalizedCheckId ?? requested,
-      infrastructureFailed: true,
-    });
-    return {
-      ...facade,
-      warnings: [...facade.warnings, `环境执行检查失败：${message.slice(0, 160)}`],
-    };
-  }
+): Promise<FacadeResult> {
+  const verification = await executeWorkVerification({
+    controllerHome: ctx.controllerHome,
+    repository: ctx.repository,
+    workId: input.workId,
+    checkId: input.checkId,
+    interactiveWaitMs: 0,
+    simulate: input.simulate
+      ? {
+          checkFailed: input.checkFailed === true,
+          infrastructureFailed: input.infrastructureFailed === true,
+        }
+      : undefined,
+  });
+  return verification.facade;
 }
 
 export function finalizeConsoleWork(ctx: ConsoleFacadeContext, workId: string): FacadeResult {
@@ -1276,6 +1261,11 @@ export function approveConsoleHandoff(ctx: ConsoleFacadeContext, handoffId: stri
     requiresApproval: payload.requiresApproval === true,
     destructive: payload.destructive === true,
     accessMode: isAccessMode(payload.accessMode) ? payload.accessMode : undefined,
+    workspaceMode: payload.workspaceMode === 'current' || payload.workspaceMode === 'isolated' || payload.workspaceMode === 'auto'
+      ? payload.workspaceMode
+      : undefined,
+    requireWorktree: typeof payload.requireWorktree === 'boolean' ? payload.requireWorktree : undefined,
+    directMainProhibited: typeof payload.directMainProhibited === 'boolean' ? payload.directMainProhibited : undefined,
     approvalConfirmed: true,
     forceMode: 'goal_workloop',
     checkIds: strings(payload.checkIds),

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

@@ -1575,12 +1575,12 @@ export async function startLocalBridgeServer(
     }
   });
 
-  app.post("/api/console/work/verify", (request, response) => {
+  app.post("/api/console/work/verify", async (request, response) => {
     try {
       const body = request.body && typeof request.body === "object" && !Array.isArray(request.body)
         ? request.body as Record<string, unknown>
         : {};
-      const result = verifyConsoleWork(consoleCtx(request), {
+      const result = await verifyConsoleWork(consoleCtx(request), {
         workId: queryString(body.workId) ?? "",
         checkId: queryString(body.checkId),
         simulate: body.simulate === true,

package/src/cli/mcp/legacy-tool-service.ts

@@ -1,4 +1,5 @@
-import type { CallToolResult as SdkCallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult, McpToolDefinition } from './tool-contract';
+export type { CallToolResult, McpToolDefinition } from './tool-contract';
 import { createHash } from "crypto";
 import {
   existsSync,
@@ -71,7 +72,8 @@ import {
 import { normalizeCheckIds } from '../../runtime/control-plane/facade/check-normalization';
 import { buildExecutionDiagnostics, buildRequirementBoard } from '../../runtime/control-plane/facade/requirement-board';
 import { acceptVerifiedTaskFromControllerWork } from '../../runtime/control-plane/execution/work-task-receipt';
-import { createWorkContract, getWorkContract } from '../../runtime/control-plane/facade/work-contract-store';
+import { getWorkContract } from '../../runtime/control-plane/facade/work-contract-store';
+import { admitDirectEditWorkContract } from '../../runtime/control-plane/facade/repository-work-admission';
 import { decideRoute } from '../../runtime/control-plane/routing/route-policy';
 import { listCapabilityDescriptors, summarizeCapabilityGroups } from '../../runtime/control-plane/facade/capability-registry';
 import {
@@ -149,6 +151,11 @@ import { hashMcpInput, tryWriteMcpAuditEntry } from "./audit";
 import { loadMcpRuntimeState } from "./auth";
 import { resolveLocalBridgeSurface, summarizeRecentJobs } from "../../runtime/shared/local-bridge-surface";
 import { resolveRepoPreferredControllerHome } from "../repositories/controller-home";
+import { resolveRepositorySelection } from '../repositories/registry';
+import { executionIdentityForRepository } from '../../runtime/control-plane/execution/execution-identity';
+import { runPersistedCheckViaProcessRuntime } from '../../runtime/gateway/mcp/persisted-check-process';
+import { getProcessRecord } from '../../runtime/execution/process-runtime/store';
+import { processCheckCompletionReceipt } from '../../runtime/execution/process-runtime/check-receipt';
 import { normalizeMcpRelativePath, resolveMcpPath } from "./paths";
 import { currentGitBranch, isForgeAdopted } from "./repo";
 import { repositoryToolNames } from "./repository-tools";
@@ -173,16 +180,6 @@ export interface McpToolContext {
   signal?: AbortSignal;
 }
 
-export interface McpToolDefinition {
-  name: string;
-  description: string;
-  inputSchema: Record<string, unknown>;
-  annotations?: Record<string, unknown>;
-}
-
-export type CallToolResult = Omit<SdkCallToolResult, "content"> & {
-  content: Array<{ type: "text"; text: string }>;
-};
 
 const EMPTY_SCHEMA = { type: "object", additionalProperties: false };
 
@@ -4317,11 +4314,6 @@ export async function callMcpTool(
         const checkIds = normalizedChecks.validCheckIds;
         const checkResults: TaskVerification['checkResults'] = [];
         if (checkIds.length > 0) {
-          const { resolveRepositorySelection } = await import('../repositories/registry');
-          const { executionIdentityForRepository } = await import('../../runtime/control-plane/execution/execution-identity');
-          const { runPersistedCheckViaProcessRuntime } = await import('../../runtime/gateway/mcp/persisted-check-process');
-          const { getProcessRecord } = await import('../../runtime/execution/process-runtime/store');
-          const { processCheckCompletionReceipt } = await import('../../runtime/execution/process-runtime/check-receipt');
           const controllerHome = resolveRepoPreferredControllerHome(ctx.repoRoot);
           const repository = resolveRepositorySelection({
             explicitPath: ctx.repoRoot,
@@ -4578,7 +4570,7 @@ export async function callMcpTool(
         const existingWork = getWorkContract(workStore, workId);
         if (requestedWorkId && !existingWork) return errorResult("WORK_NOT_FOUND", `WorkContract ${workId} not found`);
         if (!existingWork) {
-          createWorkContract(workStore, {
+          admitDirectEditWorkContract(workStore, {
             workId,
             repoId,
             checkoutId: identity.checkoutId,
@@ -4586,28 +4578,13 @@ export async function callMcpTool(
             controllerInstanceId: identity.controllerInstanceId,
             baseRevision: git.head ?? undefined,
             workspaceFingerprint: workspaceIdentity,
-            routeDecisionFingerprint: routeDecision.inputFingerprint,
             routeDecision,
-            mode: "direct_control",
             objective: purpose,
-            acceptanceCriteria: [],
-            constraints: { workspaceMode: "current", requireWorktree: false, requireHandoffOnAmbiguity: true },
-            risk: "low",
-            status: "running",
-            phase: "implementation",
             issueId: typeof args.issue_id === "string" ? args.issue_id : undefined,
             taskId: typeof args.task_id === "string" ? args.task_id : undefined,
-            scopeSummary: purpose,
             allowedPaths,
-            forbiddenPaths: [],
             checks,
             requestedBy: "chatgpt",
-            evidenceRefs: [],
-            handoffRefs: [],
-            suggestedNextActions: [],
-            policyDecisions: [],
-            checkRefs: [],
-            reconciliations: [],
           });
         }
         const session = beginEditSession(ctx.repoRoot, {

package/src/cli/mcp/post-finalize-work-attribution.ts

@@ -0,0 +1,150 @@
+import { classifyRepositoryCommand } from '../repositories/command-classifier';
+import { resolveRepositorySelection } from '../repositories/registry';
+import { executionIdentityForRepository } from '../../runtime/control-plane/execution/execution-identity';
+import { getWorkContract } from '../../runtime/control-plane/facade/work-contract-store';
+import { isTerminalWorkContractStatus } from '../../runtime/control-plane/facade/types';
+import {
+  classifyRepositoryCommandRoute,
+  executeRepositoryCommandViaProcessRuntime,
+} from '../../runtime/execution/process-runtime/command-facade';
+import {
+  callRepositoryTool,
+  type RepositoryToolCallerContext,
+} from './repository-tools';
+import type { CallToolResult } from './tools';
+
+function result(payload: Record<string, unknown>, isError = false): CallToolResult {
+  return {
+    content: [{ type: 'text', text: JSON.stringify(payload) }],
+    structuredContent: payload,
+    ...(isError ? { isError: true } : {}),
+  };
+}
+
+function optionalNumber(value: unknown): number | undefined {
+  if (typeof value === 'number' && Number.isFinite(value)) return value;
+  if (typeof value === 'string' && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : undefined;
+  }
+  return undefined;
+}
+
+/**
+ * A completed Work is historical attribution, never mutation authority.
+ *
+ * Finalize cleanup may remove the Work-owned checkout and release its Controller
+ * lease, but a Controller can still need to observe the repository immediately
+ * afterwards (for example `git status -sb`). Keep that observation attributed to
+ * the completed Work without reopening the Work lifecycle or writer lease.
+ *
+ * This path intentionally accepts only typed argv commands that the same command
+ * classifier used by Process Runtime proves readonly. Everything else falls
+ * through to the normal repository facade so active-Work ownership, terminal
+ * mutation fences, and completion-receipt remote-delivery rules stay authoritative.
+ */
+export async function callPostFinalizeWorkReadOnlyCommand(
+  controllerHome: string,
+  name: string,
+  args: Record<string, unknown>,
+  caller?: RepositoryToolCallerContext,
+): Promise<CallToolResult | undefined> {
+  if (name !== 'repository_command_execute') return undefined;
+  if (typeof args.workspace_root === 'string' && args.workspace_root.trim()) return undefined;
+
+  const requestedWorkId = typeof args.work_id === 'string' ? args.work_id.trim() : '';
+  const principalId = caller?.principalId?.trim() ?? '';
+  const command = args.command;
+  if (!requestedWorkId || !principalId || !Array.isArray(command) || !command.every((entry) => typeof entry === 'string')) {
+    return undefined;
+  }
+
+  const repository = resolveRepositorySelection({
+    repoId: typeof args.repo_id === 'string' && args.repo_id.trim() ? args.repo_id.trim() : undefined,
+    controllerHome,
+    allowSoleRepository: true,
+  });
+  if (!repository) return undefined;
+
+  const work = getWorkContract({ controllerHome, repoId: repository.repoId }, requestedWorkId);
+  if (
+    !work
+    || !isTerminalWorkContractStatus(work.status)
+    || work.status !== 'completed'
+    || !work.completionReceipt
+    || work.completionReceipt.workId !== requestedWorkId
+    || !work.principalId?.trim()
+    || work.principalId.trim() !== principalId
+  ) {
+    return undefined;
+  }
+
+  const classification = classifyRepositoryCommand(command, repository.defaultBranch);
+  if (classification.risk !== 'readonly') return undefined;
+  const route = classifyRepositoryCommandRoute(command, {
+    defaultBranch: repository.defaultBranch,
+    timeoutMs: optionalNumber(args.timeout_ms),
+  });
+  if (route.route !== 'process_direct' || route.reason !== 'readonly_fast_path') return undefined;
+
+  const executionIdentity = executionIdentityForRepository(repository, { workId: requestedWorkId });
+  const execution = await executeRepositoryCommandViaProcessRuntime({
+    controllerHome,
+    repository,
+    command,
+    cwd: typeof args.cwd === 'string' ? args.cwd : undefined,
+    timeoutMs: optionalNumber(args.timeout_ms),
+    interactiveWaitMs: optionalNumber(args.interactive_wait_ms),
+    maxOutputBytes: optionalNumber(args.max_output_bytes),
+    requestId: typeof args.request_id === 'string' ? args.request_id : undefined,
+    workId: requestedWorkId,
+    executionIdentity,
+  });
+
+  if (execution.route !== 'process_direct' || execution.process) {
+    return result({
+      accepted: false,
+      mode: 'reject',
+      path: 'post_finalize_readonly_route_mismatch',
+      route: 'reject',
+      repoId: repository.repoId,
+      checkoutId: repository.activeCheckoutId,
+      workId: requestedWorkId,
+      lifecycleClosed: true,
+      error: {
+        code: 'POST_FINALIZE_READONLY_ROUTE_MISMATCH',
+        message: 'Post-finalize Work attribution may execute only through the bounded readonly direct lane.',
+      },
+    }, true);
+  }
+
+  return result({
+    accepted: true,
+    mode: 'process_direct',
+    path: 'process_direct',
+    route: 'process_direct',
+    reason: 'post_finalize_work_readonly_followup',
+    repoId: repository.repoId,
+    checkoutId: repository.activeCheckoutId,
+    workId: requestedWorkId,
+    lifecycleClosed: true,
+    postFinalizeAttribution: 'readonly_followup',
+    completed: true,
+    ok: execution.ok === true,
+    exitCode: execution.exitCode,
+    stdout: execution.stdout,
+    stderr: execution.stderr,
+    durableSideEffects: execution.durableSideEffects,
+    next: 'Post-finalize readonly observation completed without reopening Work mutation authority or creating durable execution state.',
+  });
+}
+
+export async function callRepositoryToolWithPostFinalizeAttribution(
+  controllerHome: string,
+  name: string,
+  args: Record<string, unknown>,
+  caller?: RepositoryToolCallerContext,
+): Promise<CallToolResult | undefined> {
+  const followup = await callPostFinalizeWorkReadOnlyCommand(controllerHome, name, args, caller);
+  return followup ?? callRepositoryTool(controllerHome, name, args, caller);
+}