@contractspec/bundle.workspace 4.2.0 → 4.4.0

package/dist/ports/git.d.ts

@@ -5,6 +5,10 @@
  * Git adapter interface.
  */
 export interface GitAdapter {
+    /**
+     * Get the current branch name when available.
+     */
+    currentBranch(): Promise<string | undefined>;
     /**
      * Get file contents at a specific git ref (branch, tag, commit).
      */

package/dist/services/build.d.ts

@@ -11,7 +11,7 @@ import type { LoggerAdapter } from '../ports/logger';
 /**
  * Build target types.
  */
-export type BuildTarget = 'handler' | 'component' | 'test';
+export type BuildTarget = 'handler' | 'component' | 'test' | 'form' | 'workflow-runner' | 'data-view-renderer' | 'package-scaffold';
 /**
  * Options for building from a spec.
  */
@@ -32,6 +32,33 @@ export interface BuildSpecOptions {
      * Skip writing files (dry run).
      */
     dryRun?: boolean;
+    /**
+     * Include target-specific test artifacts in the default build plan.
+     */
+    includeTests?: boolean;
+    /**
+     * Optional runtime generation strategy supplied by higher-level callers.
+     */
+    runtimeGeneration?: RuntimeGenerationStrategy;
+}
+export type RuntimeArtifactKind = 'handler' | 'component' | 'form';
+export type RuntimeTestKind = 'handler' | 'component';
+export interface RuntimeArtifactGenerationInput {
+    kind: RuntimeArtifactKind;
+    specCode: string;
+    outputPath: string;
+    fallbackCode: string;
+}
+export interface RuntimeTestGenerationInput {
+    kind: RuntimeTestKind;
+    specCode: string;
+    outputPath: string;
+    existingCode: string;
+    fallbackCode: string;
+}
+export interface RuntimeGenerationStrategy {
+    generateArtifact?: (input: RuntimeArtifactGenerationInput) => Promise<string | null | undefined>;
+    generateTest?: (input: RuntimeTestGenerationInput) => Promise<string | null | undefined>;
 }
 /**
  * Result of a single build target.
@@ -42,6 +69,7 @@ export interface BuildTargetResult {
     success: boolean;
     skipped?: boolean;
     error?: string;
+    generatedCode?: string;
 }
 /**
  * Result of building from a spec.
@@ -49,6 +77,7 @@ export interface BuildTargetResult {
 export interface BuildSpecResult {
     specPath: string;
     specInfo: SpecScanResult;
+    targetId: string;
     results: BuildTargetResult[];
 }
 /**
@@ -59,3 +88,9 @@ export declare function buildSpec(specPath: string, adapters: {
     logger: LoggerAdapter;
     workspace?: typeof import('@contractspec/module.workspace');
 }, config: ResolvedContractsrcConfig, options?: BuildSpecOptions): Promise<BuildSpecResult>;
+/**
+ * Detect default targets based on spec type.
+ */
+export declare function resolveDefaultBuildTargets(targetId: string, options: {
+    includeTests: boolean;
+}): BuildTarget[];

package/dist/services/connect/assessment.d.ts

@@ -0,0 +1,31 @@
+import { type ConnectCommandState } from './command-policy';
+import type { ConnectImpactAnalysis } from './impact-analysis';
+import type { ConnectResolvedWorkspace } from './shared';
+import type { ConnectVerdict } from './types';
+export interface ConnectPolicyAssessment {
+    verdict: ConnectVerdict;
+    verificationStatus: 'approved' | 'revise' | 'review' | 'denied';
+    controlPlaneVerdict: 'autonomous' | 'assist' | 'blocked';
+    requiresApproval: boolean;
+    requiredApprovals: Array<{
+        capability: string;
+        reason: string;
+    }>;
+    commandState: ConnectCommandState;
+    commandMatch?: string;
+    immutablePath?: string;
+    protectedPath?: string;
+    generatedPath?: string;
+    reviewReason?: string;
+}
+export declare function assessConnectPolicy(workspace: ConnectResolvedWorkspace, input: {
+    commands?: string[];
+    impactAnalysis: ConnectImpactAnalysis;
+    smokeFailed?: boolean;
+    touchedPaths: string[];
+}): ConnectPolicyAssessment;
+export declare function connectVerdictToPolicy(verdict: ConnectVerdict): {
+    verificationStatus: 'approved' | 'revise' | 'review' | 'denied';
+    controlPlaneVerdict: 'autonomous' | 'assist' | 'blocked';
+    requiresApproval: boolean;
+};

package/dist/services/connect/audit-record.d.ts

@@ -0,0 +1,11 @@
+import type { ConnectDecisionEnvelope } from './runtime-types';
+import type { ConnectResolvedWorkspace } from './shared';
+import type { ConnectContextPack, ConnectReviewPacket, ConnectVerifyInput } from './types';
+export declare function buildConnectAuditRecord(input: {
+    contextPack: ConnectContextPack;
+    createdAt: string;
+    envelope: ConnectDecisionEnvelope;
+    reviewPacket?: ConnectReviewPacket;
+    verifyInput: ConnectVerifyInput;
+    workspace: ConnectResolvedWorkspace;
+}): Record<string, unknown>;

package/dist/services/connect/command-policy.d.ts

@@ -0,0 +1,6 @@
+import type { ConnectResolvedWorkspace } from './shared';
+export type ConnectCommandState = 'none' | 'allow' | 'review' | 'deny' | 'destructive' | 'unknown';
+export declare function classifyCommands(workspace: ConnectResolvedWorkspace, commands: string[]): {
+    state: ConnectCommandState;
+    commandMatch?: string;
+};

package/dist/services/connect/config.d.ts

@@ -0,0 +1,8 @@
+import type { ConnectVerdict } from '@contractspec/lib.contracts-spec/workspace-config';
+import type { ConnectResolvedWorkspace } from './shared';
+export declare function assertConnectEnabled(workspace: ConnectResolvedWorkspace): void;
+export declare function matchConfiguredPath(workspace: ConnectResolvedWorkspace, path: string, patterns: string[] | undefined): boolean;
+export declare function configuredThreshold(workspace: ConnectResolvedWorkspace, key: 'protectedPathWrite' | 'unknownImpact' | 'contractDrift' | 'breakingChange' | 'destructiveCommand', fallback: ConnectVerdict): ConnectVerdict;
+export declare function isAllowedCommand(workspace: ConnectResolvedWorkspace, command: string): boolean;
+export declare function isReviewCommand(workspace: ConnectResolvedWorkspace, command: string): boolean;
+export declare function isDeniedCommand(workspace: ConnectResolvedWorkspace, command: string): boolean;

package/dist/services/connect/context-plan.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/connect/context.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspaceAdapters } from '../../ports/logger';
+import type { ConnectContextPack, ConnectTaskInput } from './types';
+export declare function buildConnectContextPack(adapters: Pick<WorkspaceAdapters, 'fs' | 'git'>, input: ConnectTaskInput): Promise<ConnectContextPack>;

package/dist/services/connect/contract-refs.d.ts

@@ -0,0 +1,10 @@
+import type { ConnectContractRef } from './types';
+export declare const CONTROL_PLANE_INTENT_SUBMIT_REF: ConnectContractRef;
+export declare const CONTROL_PLANE_PLAN_COMPILE_REF: ConnectContractRef;
+export declare const CONTROL_PLANE_PLAN_VERIFY_REF: ConnectContractRef;
+export declare const CONTROL_PLANE_TRACE_GET_REF: ConnectContractRef;
+export declare const CONTROL_PLANE_POLICY_EXPLAIN_REF: ConnectContractRef;
+export declare const CONTROL_PLANE_EXECUTION_APPROVE_REF: ConnectContractRef;
+export declare const ACP_FS_ACCESS_REF: ConnectContractRef;
+export declare const ACP_TERMINAL_EXEC_REF: ConnectContractRef;
+export declare const AGENT_APPROVALS_REF: ConnectContractRef;

package/dist/services/connect/drift-outputdir.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/connect/eval.d.ts

@@ -0,0 +1,13 @@
+import type { WorkspaceAdapters } from '../../ports/logger';
+import type { ConnectEvalInput, ConnectEvaluationRuntime, ConnectWorkspaceInput } from './types';
+export declare function evaluateConnectDecision(adapters: Pick<WorkspaceAdapters, 'fs'>, input: ConnectEvalInput, runtime: ConnectEvaluationRuntime): Promise<{
+    historyDir: string;
+    evaluation: unknown;
+    context: Record<string, unknown>;
+}>;
+export declare function normalizeEvalInput(input: ConnectWorkspaceInput & {
+    decisionId: string;
+    scenarioKey?: string;
+    suiteKey?: string;
+    version?: string;
+}): ConnectEvalInput;

package/dist/services/connect/impact-analysis.d.ts

@@ -0,0 +1,25 @@
+import type { WorkspaceAdapters } from '../../ports/logger';
+import { detectImpact } from '../impact';
+import { type ConnectResolvedWorkspace } from './shared';
+import type { ConnectContractRef, ConnectSurface } from './types';
+export interface ConnectPathImpact {
+    path: string;
+    contracts: ConnectContractRef[];
+    policies: ConnectContractRef[];
+    surfaces: ConnectSurface[];
+    confidence: 'exact' | 'high' | 'medium' | 'none';
+    reasons: string[];
+}
+export interface ConnectImpactAnalysis {
+    impactedContracts: ConnectContractRef[];
+    pathImpacts: ConnectPathImpact[];
+    breakingChange: boolean;
+    driftFiles: string[];
+    impactResult?: Awaited<ReturnType<typeof detectImpact>>;
+    unknownPaths: string[];
+}
+export declare function analyzeConnectImpact(adapters: Pick<WorkspaceAdapters, 'fs' | 'git'> & Partial<Pick<WorkspaceAdapters, 'logger'>>, input: {
+    workspace: ConnectResolvedWorkspace;
+    touchedPaths: string[];
+    baseline?: string;
+}): Promise<ConnectImpactAnalysis>;

package/dist/services/connect/index.d.ts

@@ -0,0 +1,16 @@
+export * from './assessment';
+export * from './config';
+export * from './context';
+export * from './contract-refs';
+export * from './eval';
+export * from './impact-analysis';
+export * from './init';
+export * from './plan';
+export * from './replay';
+export * from './review';
+export * from './runtime-link';
+export * from './runtime-types';
+export * from './shared';
+export * from './storage';
+export * from './types';
+export * from './verify';

package/dist/services/connect/init.d.ts

@@ -0,0 +1,3 @@
+import type { FsAdapter } from '../../ports/fs';
+import type { ConnectInitInput, ConnectInitResult } from './types';
+export declare function initConnectWorkspace(fs: FsAdapter, input?: ConnectInitInput): Promise<ConnectInitResult>;

package/dist/services/connect/init.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/connect/plan-policy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/connect/plan.d.ts

@@ -0,0 +1,6 @@
+import type { WorkspaceAdapters } from '../../ports/logger';
+import type { ConnectContextPack, ConnectPlanInput, ConnectPlanPacket } from './types';
+export declare function compileConnectPlanPacket(adapters: Pick<WorkspaceAdapters, 'fs' | 'git'>, input: ConnectPlanInput): Promise<{
+    contextPack: ConnectContextPack;
+    planPacket: ConnectPlanPacket;
+}>;

package/dist/services/connect/replay-eval.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/connect/replay.d.ts

@@ -0,0 +1,6 @@
+import type { WorkspaceAdapters } from '../../ports/logger';
+import type { ConnectControlPlaneRuntime } from './runtime-types';
+import type { ConnectReplayResult, ConnectWorkspaceInput } from './types';
+export declare function replayConnectDecision(adapters: Pick<WorkspaceAdapters, 'fs'>, input: ConnectWorkspaceInput & {
+    decisionId: string;
+}, controlPlane?: ConnectControlPlaneRuntime): Promise<ConnectReplayResult>;

package/dist/services/connect/review.d.ts

@@ -0,0 +1,3 @@
+import type { WorkspaceAdapters } from '../../ports/logger';
+import type { ConnectReviewListItem, ConnectWorkspaceInput } from './types';
+export declare function listConnectReviewPackets(adapters: Pick<WorkspaceAdapters, 'fs'>, input?: ConnectWorkspaceInput): Promise<ConnectReviewListItem[]>;

package/dist/services/connect/runtime-link.d.ts

@@ -0,0 +1,7 @@
+import { type ChannelRuntimeStore, type ChannelTraceService } from '@contractspec/integration.runtime/channel';
+import type { ConnectControlPlaneRuntime } from './runtime-types';
+export declare function createConnectControlPlaneRuntime(input: {
+    store: ChannelRuntimeStore;
+    traceService: ChannelTraceService;
+    now?: () => Date;
+}): ConnectControlPlaneRuntime;

package/dist/services/connect/runtime-link.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/connect/runtime-types.d.ts

@@ -0,0 +1,48 @@
+import type { ConnectResolvedWorkspace } from './shared';
+import type { ConnectPatchVerdict, ConnectPlanPacket, ConnectRuntimeLink, ConnectVerdict, ConnectVerifyInput } from './types';
+export interface ConnectTraceLookup {
+    decisionId?: string;
+    traceId?: string;
+}
+export interface ConnectReviewBridgeState {
+    enabled: boolean;
+    mode?: 'off' | 'review-bridge';
+    endpoint?: string;
+    queue?: string;
+    status: 'disabled' | 'skipped' | 'synced' | 'failed';
+    lastAttemptAt?: string;
+    syncedAt?: string;
+    reviewId?: string;
+    laneRunId?: string;
+    runtimeDecisionId?: string;
+    traceId?: string;
+    error?: string;
+}
+export interface ConnectDecisionEnvelope {
+    connectDecisionId: string;
+    taskId: string;
+    verdict: ConnectVerdict;
+    createdAt: string;
+    artifacts: {
+        contextPack: string;
+        planPacket: string;
+        patchVerdict: string;
+        reviewPacket?: string;
+        evaluationResult?: string;
+        replayBundle?: string;
+    };
+    runtimeLink?: ConnectRuntimeLink;
+    reviewBridge?: ConnectReviewBridgeState;
+}
+export interface ConnectControlPlaneRuntime {
+    linkDecision(input: {
+        connectDecisionId: string;
+        input: ConnectVerifyInput;
+        workspace: ConnectResolvedWorkspace;
+        planPacket: ConnectPlanPacket;
+        patchVerdict: ConnectPatchVerdict;
+        createdAt: string;
+    }): Promise<ConnectRuntimeLink | null>;
+    getExecutionTrace(input: ConnectTraceLookup): Promise<unknown | null>;
+    replayExecutionTrace(input: ConnectTraceLookup): Promise<unknown | null>;
+}

package/dist/services/connect/shared.d.ts

@@ -0,0 +1,14 @@
+import { type ResolvedContractsrcConfig } from '@contractspec/lib.contracts-spec/workspace-config';
+import type { ConnectActorRef, ConnectSurface, ConnectWorkspaceInput } from './types';
+export interface ConnectResolvedWorkspace {
+    cwd: string;
+    workspaceRoot: string;
+    packageRoot: string;
+    config: ResolvedContractsrcConfig;
+    repoId: string;
+    branch: string;
+}
+export declare function resolveWorkspace(input?: ConnectWorkspaceInput): ConnectResolvedWorkspace;
+export declare function withBranch<T extends ConnectResolvedWorkspace>(workspace: T, branch: string | undefined): T;
+export declare function defaultActor(taskId: string, actor?: ConnectActorRef): ConnectActorRef;
+export declare function inferSurfaces(paths: string[]): ConnectSurface[];

package/dist/services/connect/storage.d.ts

@@ -0,0 +1,50 @@
+import type { FsAdapter } from '../../ports/fs';
+import type { ConnectDecisionEnvelope } from './runtime-types';
+import type { ConnectResolvedWorkspace } from './shared';
+import type { ConnectContextPack, ConnectPatchVerdict, ConnectPlanPacket, ConnectReviewListItem, ConnectReviewPacket } from './types';
+export interface ConnectStoragePaths {
+    root: string;
+    contextPack: string;
+    planPacket: string;
+    patchVerdict: string;
+    auditFile: string;
+    reviewPacketsDir: string;
+    decisionsDir: string;
+}
+export interface ConnectStoredDecision {
+    historyDir: string;
+    contextPack?: ConnectContextPack;
+    planPacket?: ConnectPlanPacket;
+    patchVerdict?: ConnectPatchVerdict;
+    reviewPacket?: ConnectReviewPacket;
+    envelope?: ConnectDecisionEnvelope;
+}
+export declare function resolveStoragePaths(workspace: ConnectResolvedWorkspace): ConnectStoragePaths;
+export declare function ensureStorage(fs: FsAdapter, storage: ConnectStoragePaths): Promise<void>;
+export declare function persistLatestArtifacts(fs: FsAdapter, storage: ConnectStoragePaths, artifacts: {
+    contextPack?: ConnectContextPack;
+    planPacket?: ConnectPlanPacket;
+    patchVerdict?: ConnectPatchVerdict;
+}): Promise<void>;
+export declare function persistDecisionArtifacts(fs: FsAdapter, storage: ConnectStoragePaths, decisionId: string, artifacts: {
+    contextPack?: ConnectContextPack;
+    planPacket?: ConnectPlanPacket;
+    patchVerdict?: ConnectPatchVerdict;
+    reviewPacket?: ConnectReviewPacket;
+    evaluationResult?: unknown;
+    replayBundle?: unknown;
+}): Promise<string>;
+export declare function writeDecisionEnvelope(fs: FsAdapter, storage: ConnectStoragePaths, decisionId: string, envelope: ConnectDecisionEnvelope): Promise<string>;
+export declare function appendAuditRecord(fs: FsAdapter, storage: ConnectStoragePaths, record: Record<string, unknown>): Promise<void>;
+export declare function writeReviewPacket(fs: FsAdapter, storage: ConnectStoragePaths, packet: ConnectReviewPacket): Promise<string>;
+export declare function loadStoredDecision(fs: FsAdapter, storage: ConnectStoragePaths, decisionId: string): Promise<ConnectStoredDecision>;
+export declare function listStoredReviewPackets(fs: FsAdapter, storage: ConnectStoragePaths): Promise<ConnectReviewListItem[]>;
+export declare function artifactRef(fs: FsAdapter, workspace: ConnectResolvedWorkspace, path: string): string;
+export declare function decisionArtifactRefs(fs: FsAdapter, workspace: ConnectResolvedWorkspace, storage: ConnectStoragePaths, decisionId: string, artifacts: {
+    contextPack?: boolean;
+    planPacket?: boolean;
+    patchVerdict?: boolean;
+    reviewPacket?: boolean;
+    evaluationResult?: boolean;
+    replayBundle?: boolean;
+}): ConnectDecisionEnvelope['artifacts'];

package/dist/services/connect/types.d.ts

@@ -0,0 +1,250 @@
+import type { ConnectVerdict, ResolvedContractsrcConfig } from '@contractspec/lib.contracts-spec/workspace-config';
+import type { SetupFileResult, SetupGitignoreBehavior, SetupPromptCallbacks } from '../setup/types';
+export type { ConnectVerdict };
+export type ConnectActorType = 'human' | 'agent' | 'service' | 'tool';
+export type ConnectApprovalStatus = 'not_required' | 'pending' | 'approved' | 'rejected' | 'expired';
+export type ConnectSurface = 'agent' | 'audit' | 'cli' | 'contract' | 'harness' | 'knowledge' | 'mcp' | 'runtime';
+export type ConnectContractKind = 'command' | 'query' | 'event' | 'policy' | 'capability';
+export interface ConnectActorRef {
+    id: string;
+    type: ConnectActorType;
+    sessionId?: string;
+    traceId?: string;
+}
+export interface ConnectContractRef {
+    key: string;
+    version: string;
+    kind?: ConnectContractKind;
+}
+export interface ConnectRuntimeLink {
+    decisionId: string;
+    traceId?: string;
+    planId?: string;
+    approvalStatus?: ConnectApprovalStatus;
+    workspaceId?: string;
+    providerKey?: string;
+    receiptId?: string;
+    threadId?: string;
+}
+export interface ConnectWorkspaceInput {
+    cwd?: string;
+    workspaceRoot?: string;
+    packageRoot?: string;
+    config?: ResolvedContractsrcConfig;
+}
+export interface ConnectInitInput extends ConnectWorkspaceInput {
+    scope?: 'workspace' | 'package';
+    interactive?: boolean;
+    gitignoreBehavior?: SetupGitignoreBehavior;
+    prompts?: Pick<SetupPromptCallbacks, 'confirm'>;
+}
+export interface ConnectInitResult {
+    configPath: string;
+    targetRoot: string;
+    action: 'created' | 'merged';
+    gitignore: SetupFileResult;
+}
+export interface ConnectTaskInput extends ConnectWorkspaceInput {
+    taskId: string;
+    actor?: ConnectActorRef;
+    baseline?: string;
+    paths?: string[];
+}
+export interface ConnectContextPack {
+    id: string;
+    taskId: string;
+    repoId: string;
+    branch: string;
+    actor: ConnectActorRef;
+    knowledge: Array<{
+        spaceKey: string;
+        category: 'canonical' | 'operational' | 'external' | 'ephemeral';
+        trustLevel: 'high' | 'medium' | 'low';
+        source: string;
+        digest?: string;
+    }>;
+    impactedContracts: ConnectContractRef[];
+    affectedSurfaces: ConnectSurface[];
+    policyBindings: Array<{
+        key: string;
+        version: string;
+        source: 'contract' | 'canon-pack' | 'workspace-config';
+        authority: 'canonical' | 'operational';
+    }>;
+    configRefs: Array<{
+        kind: 'contractsrc' | 'artifact' | 'canon-pack';
+        ref: string;
+    }>;
+    acceptanceChecks: string[];
+}
+export interface ConnectPlanStep {
+    id: string;
+    summary: string;
+    paths?: string[];
+    commands?: string[];
+    contractRefs?: string[];
+}
+export interface ConnectPlanPacket {
+    id: string;
+    taskId: string;
+    repoId: string;
+    branch: string;
+    actor: ConnectActorRef;
+    objective: string;
+    steps: ConnectPlanStep[];
+    impactedContracts: ConnectContractRef[];
+    affectedSurfaces: ConnectSurface[];
+    requiredChecks: string[];
+    requiredApprovals: Array<{
+        capability: string;
+        reason: string;
+    }>;
+    riskScore: number;
+    verificationStatus: 'approved' | 'revise' | 'review' | 'denied';
+    controlPlane: {
+        intentSubmit: ConnectContractRef;
+        planCompile: ConnectContractRef;
+        planVerify: ConnectContractRef;
+        decisionId?: string;
+        traceId?: string;
+    };
+    acpActions?: Array<'acp.fs.access' | 'acp.terminal.exec' | 'acp.tool.calls'>;
+}
+export interface ConnectImpactedFile {
+    file: string;
+    contracts: ConnectContractRef[];
+    surfaces: ConnectSurface[];
+    policies: ConnectContractRef[];
+}
+export interface ConnectPatchVerdict {
+    decisionId: string;
+    summary?: string;
+    action: {
+        actionType: 'write_file' | 'edit_file' | 'run_command';
+        tool: 'acp.fs.access' | 'acp.terminal.exec' | 'acp.tool.calls';
+        target?: string;
+        cwd?: string;
+    };
+    impacted: ConnectImpactedFile[];
+    checks: Array<{
+        id: string;
+        status: 'pass' | 'fail' | 'warn';
+        detail: string;
+    }>;
+    verdict: ConnectVerdict;
+    controlPlane: {
+        verdict: 'autonomous' | 'assist' | 'blocked';
+        requiresApproval: boolean;
+        policyRef?: ConnectContractRef;
+        decisionId?: string;
+        approvalStatus?: ConnectApprovalStatus;
+        traceId?: string;
+    };
+    approvalOperationRefs?: string[];
+    remediation?: string[];
+    reviewPacketRef?: string;
+    retryBudget?: number;
+    replay: {
+        traceQuery: ConnectContractRef;
+        policyExplain?: ConnectContractRef;
+    };
+}
+export interface ConnectReviewPacket {
+    id: string;
+    sourceDecisionId: string;
+    objective: string;
+    reason: string;
+    summary: {
+        paths: string[];
+        impactedContracts: ConnectContractRef[];
+        affectedSurfaces: ConnectSurface[];
+        requiredChecks: string[];
+    };
+    evidence: Array<{
+        type: 'context-pack' | 'plan-packet' | 'patch-verdict' | 'control-plane-trace';
+        ref: string;
+    }>;
+    requiredApprovals: Array<{
+        capability: string;
+        reason: string;
+    }>;
+    controlPlane: {
+        traceQuery: ConnectContractRef;
+        policyExplain: ConnectContractRef;
+        decisionId?: string;
+        approvalStatus?: ConnectApprovalStatus;
+        traceId?: string;
+    };
+    studio?: {
+        enabled?: boolean;
+        mode?: 'off' | 'review-bridge';
+        queue?: string;
+    };
+}
+export interface ConnectPlanInput extends ConnectTaskInput {
+    candidate: {
+        objective: string;
+        steps?: Array<string | Omit<ConnectPlanStep, 'id'>>;
+        touchedPaths?: string[];
+        commands?: string[];
+    };
+}
+export interface ConnectVerifyFsAccessInput extends ConnectTaskInput {
+    tool: 'acp.fs.access';
+    operation: string;
+    path: string;
+    content?: string;
+    options?: Record<string, unknown>;
+}
+export interface ConnectVerifyTerminalExecInput extends ConnectTaskInput {
+    tool: 'acp.terminal.exec';
+    command: string;
+    cwd?: string;
+    touchedPaths?: string[];
+}
+export type ConnectVerifyInput = ConnectVerifyFsAccessInput | ConnectVerifyTerminalExecInput;
+export interface ConnectCommandResult {
+    command: string;
+    cwd?: string;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface ConnectVerifyRuntime {
+    runCommand?: (command: string, options?: {
+        cwd?: string;
+    }) => Promise<ConnectCommandResult>;
+}
+export interface ConnectReplayResult {
+    decisionId: string;
+    historyDir: string;
+    contextPack?: ConnectContextPack;
+    planPacket?: ConnectPlanPacket;
+    patchVerdict?: ConnectPatchVerdict;
+    reviewPacket?: ConnectReviewPacket;
+    trace?: unknown;
+    replay?: unknown;
+    source: 'local' | 'local+control-plane';
+}
+export interface ConnectEvaluationRuntime {
+    runScenarioEvaluation(input: {
+        scenarioKey: string;
+        version?: string;
+        context?: Record<string, unknown>;
+    }): Promise<unknown>;
+    runSuiteEvaluation(input: {
+        suiteKey: string;
+        version?: string;
+        context?: Record<string, unknown>;
+    }): Promise<unknown>;
+}
+export interface ConnectEvalInput extends ConnectWorkspaceInput {
+    decisionId: string;
+    scenarioKey?: string;
+    suiteKey?: string;
+    version?: string;
+}
+export interface ConnectReviewListItem {
+    filePath: string;
+    packet: ConnectReviewPacket;
+}

package/dist/services/connect/verdict-mapping.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/connect/verify-boundaries.test.d.ts

@@ -0,0 +1 @@
+export {};