@phuetz/code-buddy 0.3.0 → 1.0.0-rc.8

package/dist/agent/autonomous/agentic-coding-runner.d.ts

@@ -0,0 +1,1710 @@
+import { type AgenticCodingApprovalDecision, type AgenticCodingExecutionGate, type AgenticCodingTaskContract, type AgenticCodingWorkflowBuilderProposal } from './agentic-coding-contract.js';
+import { type AgenticCodingCheckpoint } from './checkpoint-manager.js';
+import { normalizeGitPath, isPathAllowedByContract, resolveRepoPath } from './agentic-coding-paths.js';
+export { normalizeGitPath, isPathAllowedByContract, resolveRepoPath };
+import { type GitNexusContext, type WorldModelInvariants } from '../../tools/gitnexus-tool.js';
+import type { FleetDispatchProfile } from '../../fleet/dispatch-profile.js';
+import { persistRunArtifact, applyDeclaredEdits, previewDeclaredEdits, runVerificationCommands } from './agentic-coding-edits.js';
+export { persistRunArtifact, applyDeclaredEdits, previewDeclaredEdits, runVerificationCommands };
+export type AgenticCodingRunStatus = 'validation_failed' | 'blocked' | 'ready' | 'previewed' | 'edited' | 'verified' | 'verification_failed';
+export interface AgenticCodingRunOptions {
+    applyEdits?: boolean;
+    approvalDecisionFile?: string;
+    editProposalFile?: string;
+    generatedAt?: string;
+    previewEdits?: boolean;
+    requireApproval?: boolean;
+    requirePreview?: boolean;
+    runVerification?: boolean;
+    taskFile?: string;
+    verificationTimeoutMs?: number;
+    workflowBuilderProposalFile?: string;
+    runId?: string;
+    resume?: string;
+    skipDecomposition?: boolean;
+    contract?: AgenticCodingTaskContract;
+    maxCostUsd?: number;
+    maxIterations?: number;
+    recordObservability?: boolean;
+}
+export interface AgenticCodingRulesFile {
+    path: string;
+    present: boolean;
+}
+export interface AgenticCodingDirtyFile {
+    path: string;
+    status: string;
+    allowed: boolean;
+}
+export interface AgenticCodingVerificationResult {
+    command: string;
+    exitCode: number;
+    status: 'passed' | 'failed' | 'blocked';
+    stdout: string;
+    stderr: string;
+    reason?: string;
+}
+export interface AgenticCodingEditResult {
+    path: string;
+    status: 'applied' | 'blocked' | 'failed';
+    occurrences: number;
+    reason?: string;
+}
+export interface AgenticCodingEditPreview {
+    after: string;
+    before: string;
+    occurrences: number;
+    path: string;
+    reason?: string;
+    status: 'previewed' | 'blocked' | 'failed';
+}
+export type AgenticCodingApprovalState = 'not_required' | 'draft' | 'needs_approval' | 'approved' | 'rejected';
+export interface AgenticCodingApprovalReport {
+    reason: string;
+    requiredBeforeApply: boolean;
+    state: AgenticCodingApprovalState;
+}
+export interface AgenticCodingApprovalDecisionReport {
+    decidedAt?: string;
+    decision: AgenticCodingApprovalDecision['decision'];
+    file: string;
+    reason: string;
+    reviewer: string;
+}
+export interface AgenticCodingApprovalSnapshot {
+    decision?: {
+        decidedAt?: string;
+        decision: AgenticCodingApprovalDecisionReport['decision'];
+        file: string;
+        reason: string;
+        reviewer: string;
+    };
+    editSummary: {
+        applied: number;
+        blocked: number;
+        declared: number;
+        files: string[];
+        previewed: number;
+        proposal?: {
+            file: string;
+            producer?: string;
+            risks: string[];
+            summary: string;
+            verificationNotes: string[];
+        };
+    };
+    gateNodeIds: string[];
+    generatedAt: string;
+    kind: 'agentic-coding-approval-state';
+    nextAction: {
+        message: string;
+        nodeId?: string;
+        type: 'none' | 'preview_required' | 'review_preview' | 'inspect_rejection';
+    };
+    reason: string;
+    requiredBeforeApply: boolean;
+    schemaVersion: 1;
+    source: {
+        activeNodeId?: string;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+    state: AgenticCodingApprovalState;
+}
+export interface AgenticCodingEditProposalReport {
+    editCount: number;
+    file: string;
+    producer?: string;
+    risks: string[];
+    summary: string;
+    verificationNotes: string[];
+}
+export type AgenticCodingEditProposalReviewState = 'missing' | 'accepted' | 'rejected';
+export interface AgenticCodingEditProposalReviewSnapshot {
+    editSummary: {
+        declared: number;
+        files: string[];
+        proposal?: AgenticCodingEditProposalReport;
+    };
+    generatedAt: string;
+    kind: 'agentic-coding-edit-proposal-review';
+    nextAction: {
+        message: string;
+        stepId?: string;
+        type: 'produce_edit_proposal' | 'fix_edit_proposal' | 'preview_edits';
+    };
+    reason: string;
+    schemaVersion: 1;
+    source: {
+        proposalFile?: string;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+    state: AgenticCodingEditProposalReviewState;
+    validationErrors: string[];
+}
+export interface AgenticCodingWorkflowBuilderProposalReport {
+    approvalGates: string[];
+    coworkVisualizationNotes: string[];
+    edgeCount: number;
+    edges: AgenticCodingWorkflowBuilderProposal['edges'];
+    file: string;
+    nodeCount: number;
+    nodes: AgenticCodingWorkflowBuilderProposal['nodes'];
+    risks: string[];
+    summary: string;
+}
+export type AgenticCodingPlanStepStatus = 'completed' | 'ready' | 'blocked' | 'pending' | 'skipped';
+export interface AgenticCodingPlanStep {
+    id: string;
+    title: string;
+    status: AgenticCodingPlanStepStatus;
+    detail: string;
+}
+export type AgenticCodingWorkflowNodeType = 'gate' | 'analysis' | 'approval' | 'edit' | 'verification' | 'handoff';
+export interface AgenticCodingWorkflowNode {
+    id: string;
+    type: AgenticCodingWorkflowNodeType;
+    label: string;
+    status: AgenticCodingPlanStepStatus;
+    detail: string;
+}
+export interface AgenticCodingWorkflowEdge {
+    animated: boolean;
+    id: string;
+    source: string;
+    target: string;
+}
+export interface AgenticCodingWorkflowNodeError {
+    message: string;
+    nodeId: string;
+}
+export interface AgenticCodingWorkflowReport {
+    activeNodeId?: string;
+    blockedNodeIds: string[];
+    completedNodeIds: string[];
+    edges: AgenticCodingWorkflowEdge[];
+    nodeErrors: AgenticCodingWorkflowNodeError[];
+    nodes: AgenticCodingWorkflowNode[];
+}
+export interface AgenticCodingWorkflowCanvasNode {
+    data: {
+        agenticType: AgenticCodingWorkflowNodeType;
+        description: string;
+        errorMessages: string[];
+        iconName: string;
+        label: string;
+        status: AgenticCodingPlanStepStatus;
+        type: 'trigger' | 'action' | 'logic';
+    };
+    id: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    type: 'customNode';
+}
+export interface AgenticCodingWorkflowCanvasEdge {
+    animated: true;
+    id: string;
+    source: string;
+    style: {
+        stroke: string;
+        strokeWidth: number;
+    };
+    target: string;
+}
+export interface AgenticCodingWorkflowCanvas {
+    activeNodeId?: string;
+    blockedNodeIds: string[];
+    completedNodeIds: string[];
+    edges: AgenticCodingWorkflowCanvasEdge[];
+    generatedAt: string;
+    kind: 'agentic-coding-workflow-canvas';
+    nodeErrors: AgenticCodingWorkflowNodeError[];
+    nodes: AgenticCodingWorkflowCanvasNode[];
+    schemaVersion: 1;
+    source: {
+        approvalState: AgenticCodingApprovalState;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+}
+export interface AgenticCodingWorkflowBuilderProposalCanvas {
+    edges: AgenticCodingWorkflowCanvasEdge[];
+    generatedAt: string;
+    kind: 'agentic-coding-workflow-builder-proposal-canvas';
+    nodes: AgenticCodingWorkflowCanvasNode[];
+    schemaVersion: 1;
+    source: {
+        proposalFile: string;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+    summary: string;
+}
+export interface AgenticCodingWorkflowProgressSnapshot {
+    activeNodeId?: string;
+    approvalState: AgenticCodingApprovalState;
+    blockedNodeIds: string[];
+    completedNodeIds: string[];
+    counts: {
+        blocked: number;
+        completed: number;
+        pending: number;
+        ready: number;
+        skipped: number;
+        total: number;
+    };
+    fleet: AgenticCodingFleetCollaborationPlan;
+    generatedAt: string;
+    kind: 'agentic-coding-workflow-progress';
+    nextAction: {
+        message: string;
+        nodeId?: string;
+        type: 'inspect_blocker' | 'approve_preview' | 'continue' | 'complete';
+    };
+    nodeErrors: AgenticCodingWorkflowNodeError[];
+    nodes: Array<{
+        errorMessages: string[];
+        id: string;
+        label: string;
+        status: AgenticCodingPlanStepStatus;
+        type: AgenticCodingWorkflowNodeType;
+    }>;
+    schemaVersion: 1;
+    source: {
+        fleetMode: AgenticCodingFleetCollaborationMode;
+        fleetPolicy: AgenticCodingTaskContract['fleetPolicy'];
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+}
+export type AgenticCodingWorkflowEventSeverity = 'info' | 'success' | 'warning' | 'error';
+export interface AgenticCodingWorkflowEvent {
+    active: boolean;
+    id: string;
+    message: string;
+    nodeId: string;
+    nodeType: AgenticCodingWorkflowNodeType;
+    sequence: number;
+    severity: AgenticCodingWorkflowEventSeverity;
+    status: AgenticCodingPlanStepStatus;
+}
+export interface AgenticCodingWorkflowEventsSnapshot {
+    activeNodeId?: string;
+    events: AgenticCodingWorkflowEvent[];
+    generatedAt: string;
+    kind: 'agentic-coding-workflow-events';
+    schemaVersion: 1;
+    source: {
+        approvalState: AgenticCodingApprovalState;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+}
+export type AgenticCodingProposalLoopNextActionType = 'inspect_blocker' | 'generate_edit_proposal' | 'review_edit_proposal' | 'fix_edit_proposal' | 'preview_edits' | 'review_preview' | 'apply_approved_edits' | 'run_verification' | 'handoff';
+export interface AgenticCodingProposalLoopCommand {
+    args: string[];
+    executable: 'buddy';
+}
+export interface AgenticCodingProposalLoopStep {
+    command?: AgenticCodingProposalLoopCommand;
+    id: string;
+    inputArtifacts: string[];
+    label: string;
+    outputArtifacts: string[];
+    safety: string[];
+    status: AgenticCodingPlanStepStatus;
+}
+export interface AgenticCodingProposalLoopArtifacts {
+    applyReportFile: string;
+    approvalDecisionFile: string;
+    approvalDecisionPromptFile: string;
+    approvalFile: string;
+    editProposalFile: string;
+    editProposalProducerDispatchFile: string;
+    editProposalReviewFile: string;
+    previewReportFile: string;
+    proposalPromptFile: string;
+    workflowEventsFile: string;
+    workflowProgressFile: string;
+}
+export interface AgenticCodingProposalLoopArtifactBundlePaths extends AgenticCodingProposalLoopArtifacts {
+    artifactBundleFile: string;
+    editProposalRequestFile: string;
+    proposalLoopNextActionFile: string;
+    proposalLoopCanvasFile: string;
+    proposalLoopFile: string;
+    seedReportFile: string;
+}
+export interface AgenticCodingProposalLoopMaterializedArtifact {
+    path: string;
+    role: string;
+    safety: string;
+}
+export type AgenticCodingProposalLoopCoworkPanelView = 'canvas' | 'queue' | 'review' | 'prompt' | 'state' | 'timeline' | 'evidence' | 'manifest';
+export interface AgenticCodingProposalLoopCoworkImportPanel {
+    artifactPath: string;
+    id: string;
+    role: string;
+    title: string;
+    view: AgenticCodingProposalLoopCoworkPanelView;
+}
+export interface AgenticCodingProposalLoopCoworkImport {
+    defaultPanelId: string;
+    panels: AgenticCodingProposalLoopCoworkImportPanel[];
+    primaryArtifactPath: string;
+    queueArtifactPath: string;
+    requiredArtifactPaths: string[];
+    schemaVersion: 1;
+    suggestedFocusPanelId: string;
+    summary: string;
+}
+export type AgenticCodingProposalLoopCoworkImportCheckStatus = 'ready' | 'missing_required' | 'invalid';
+export interface AgenticCodingProposalLoopCoworkImportArtifactCheck {
+    exists: boolean;
+    path: string;
+    resolvedPath: string;
+}
+export interface AgenticCodingProposalLoopCoworkImportPanelCheck extends AgenticCodingProposalLoopCoworkImportPanel {
+    exists: boolean;
+    required: boolean;
+    resolvedArtifactPath: string;
+}
+export interface AgenticCodingProposalLoopCoworkImportCheck {
+    defaultPanelId?: string;
+    generatedAt: string;
+    kind: 'agentic-coding-proposal-loop-cowork-import-check';
+    missingRequiredArtifactPaths: string[];
+    panels: AgenticCodingProposalLoopCoworkImportPanelCheck[];
+    primaryArtifactPath?: string;
+    primaryArtifactExists: boolean;
+    queueArtifactExists: boolean;
+    requiredArtifacts: AgenticCodingProposalLoopCoworkImportArtifactCheck[];
+    resolvedPrimaryArtifactPath?: string;
+    schemaVersion: 1;
+    source: {
+        importFile: string;
+        summary?: string;
+    };
+    status: AgenticCodingProposalLoopCoworkImportCheckStatus;
+    suggestedFocusPanelId?: string;
+    validationErrors: string[];
+}
+export type AgenticCodingProposalLoopCoworkWorkspaceStatus = 'ready' | 'needs_artifacts' | 'invalid';
+export type AgenticCodingProposalLoopCoworkWorkspaceActionType = 'open_panel' | 'resolve_missing' | 'fix_import';
+export interface AgenticCodingProposalLoopCoworkWorkspace {
+    activity?: {
+        activeEventId?: string;
+        activeNodeId?: string;
+        artifactPath: string;
+        counts: {
+            error: number;
+            info: number;
+            success: number;
+            total: number;
+            warning: number;
+        };
+        events: Array<{
+            active: boolean;
+            id: string;
+            message: string;
+            nodeId: string;
+            nodeType: AgenticCodingWorkflowNodeType;
+            sequence: number;
+            severity: AgenticCodingWorkflowEventSeverity;
+            status: AgenticCodingPlanStepStatus;
+        }>;
+        exists: boolean;
+        resolvedArtifactPath: string;
+        validationErrors: string[];
+    };
+    approval?: {
+        affectedFiles: string[];
+        artifactPath: string;
+        editSummary?: {
+            applied: number;
+            blocked: number;
+            declared: number;
+            previewed: number;
+        };
+        exists: boolean;
+        gateNodeIds: string[];
+        nextAction?: AgenticCodingApprovalSnapshot['nextAction'];
+        reason?: string;
+        requiredBeforeApply?: boolean;
+        resolvedArtifactPath: string;
+        sourceActiveNodeId?: string;
+        state?: AgenticCodingApprovalState;
+        validationErrors: string[];
+    };
+    commands?: {
+        artifactPath: string;
+        commandCount: number;
+        commands: Array<{
+            canRunNow: boolean;
+            command: AgenticCodingProposalLoopCommand;
+            commandText: string;
+            id: string;
+            inputArtifacts: string[];
+            label: string;
+            outputArtifacts: string[];
+            safety: string[];
+            status: AgenticCodingPlanStepStatus;
+        }>;
+        exists: boolean;
+        readyCommandCount: number;
+        resolvedArtifactPath: string;
+        validationErrors: string[];
+    };
+    evidence?: {
+        approvalState?: AgenticCodingApprovalState;
+        artifactPath: string;
+        autoExecutable?: boolean;
+        blockedReasons: string[];
+        editSummary: {
+            applied: number;
+            blocked: number;
+            declared: number;
+            previewed: number;
+        };
+        exists: boolean;
+        resolvedArtifactPath: string;
+        runGeneratedAt?: string;
+        status?: AgenticCodingRunStatus;
+        validationErrors: string[];
+        verificationSummary: {
+            blocked: number;
+            failed: number;
+            passed: number;
+            total: number;
+        };
+        workflow?: {
+            activeNodeId?: string;
+            blocked: number;
+            completed: number;
+            total: number;
+        };
+    };
+    graph?: {
+        activeNodeId?: string;
+        approvalNodeIds: string[];
+        artifactPath: string;
+        blockedNodeIds: string[];
+        edgeCount: number;
+        edges: Array<{
+            animated: boolean;
+            id: string;
+            source: string;
+            target: string;
+        }>;
+        exists: boolean;
+        nodeCount: number;
+        nodes: Array<{
+            active: boolean;
+            canvasType: 'trigger' | 'action' | 'logic';
+            id: string;
+            iconName: string;
+            label: string;
+            position: {
+                x: number;
+                y: number;
+            };
+            status: AgenticCodingPlanStepStatus;
+            type: AgenticCodingWorkflowNodeType;
+        }>;
+        resolvedArtifactPath: string;
+        statusCounts: AgenticCodingProposalLoopSnapshot['counts'];
+        validationErrors: string[];
+    };
+    graphLegend?: {
+        activeNodeId?: string;
+        edgeCount: number;
+        mode: 'passive';
+        nodeCount: number;
+        nodeTypes: Array<{
+            canvasTypes: Array<'trigger' | 'action' | 'logic'>;
+            count: number;
+            iconNames: string[];
+            id: AgenticCodingWorkflowNodeType;
+            label: string;
+        }>;
+        safetyNote: string;
+        statuses: Array<{
+            count: number;
+            id: AgenticCodingPlanStepStatus;
+            label: string;
+            tone: 'neutral' | 'success' | 'warning' | 'danger';
+        }>;
+    };
+    graphViewport?: {
+        activeNodeId?: string;
+        activePosition?: {
+            x: number;
+            y: number;
+        };
+        activeTrailEdgeIds: string[];
+        activeTrailNodeIds: string[];
+        activeTrailProgress?: {
+            activeIndex: number;
+            activeOrdinal: number;
+            ratio: number;
+            totalEdgeCount: number;
+            totalNodeCount: number;
+            trailEdgeCount: number;
+            trailNodeCount: number;
+        };
+        activeTrailSegments: Array<{
+            edgeId: string;
+            source: string;
+            sourcePosition: {
+                x: number;
+                y: number;
+            };
+            target: string;
+            targetPosition: {
+                x: number;
+                y: number;
+            };
+        }>;
+        upcomingTrailEdgeIds: string[];
+        upcomingTrailNodeIds: string[];
+        upcomingTrailSegments: Array<{
+            edgeId: string;
+            source: string;
+            sourcePosition: {
+                x: number;
+                y: number;
+            };
+            target: string;
+            targetPosition: {
+                x: number;
+                y: number;
+            };
+        }>;
+        upcomingTrailBounds?: {
+            height: number;
+            maxX: number;
+            maxY: number;
+            minX: number;
+            minY: number;
+            width: number;
+        };
+        upcomingTrailProgress?: {
+            remainingEdgeCount: number;
+            remainingNodeCount: number;
+            remainingRatio: number;
+            totalEdgeCount: number;
+            totalNodeCount: number;
+        };
+        trailProgressSummary?: {
+            activeNodeId: string;
+            isAtEnd: boolean;
+            reachedEdgeCount: number;
+            reachedNodeCount: number;
+            reachedRatio: number;
+            remainingEdgeCount: number;
+            remainingNodeCount: number;
+            remainingRatio: number;
+            totalEdgeCount: number;
+            totalNodeCount: number;
+        };
+        activeTrailBounds?: {
+            height: number;
+            maxX: number;
+            maxY: number;
+            minX: number;
+            minY: number;
+            width: number;
+        };
+        bounds: {
+            height: number;
+            maxX: number;
+            maxY: number;
+            minX: number;
+            minY: number;
+            width: number;
+        };
+        center: {
+            x: number;
+            y: number;
+        };
+        edgeCount: number;
+        activeIndex?: number;
+        statusBounds: Array<{
+            bounds: {
+                height: number;
+                maxX: number;
+                maxY: number;
+                minX: number;
+                minY: number;
+                width: number;
+            };
+            count: number;
+            id: AgenticCodingPlanStepStatus;
+            label: string;
+            nodeIds: string[];
+            tone: 'neutral' | 'success' | 'warning' | 'danger';
+        }>;
+        statusTransitions: Array<{
+            count: number;
+            edgeIds: string[];
+            from: AgenticCodingPlanStepStatus;
+            fromNodeIds: string[];
+            fromTone: 'neutral' | 'success' | 'warning' | 'danger';
+            id: string;
+            isCrossStatus: boolean;
+            label: string;
+            to: AgenticCodingPlanStepStatus;
+            toNodeIds: string[];
+            toTone: 'neutral' | 'success' | 'warning' | 'danger';
+        }>;
+        statusTransitionBridges: Array<{
+            count: number;
+            edgeIds: string[];
+            from: AgenticCodingPlanStepStatus;
+            fromBounds: {
+                height: number;
+                maxX: number;
+                maxY: number;
+                minX: number;
+                minY: number;
+                width: number;
+            };
+            fromCenter: {
+                x: number;
+                y: number;
+            };
+            fromTone: 'neutral' | 'success' | 'warning' | 'danger';
+            id: string;
+            isCrossStatus: true;
+            label: string;
+            to: AgenticCodingPlanStepStatus;
+            toBounds: {
+                height: number;
+                maxX: number;
+                maxY: number;
+                minX: number;
+                minY: number;
+                width: number;
+            };
+            toCenter: {
+                x: number;
+                y: number;
+            };
+            toTone: 'neutral' | 'success' | 'warning' | 'danger';
+        }>;
+        statusTransitionBridgeSummary?: {
+            allBridgesCrossStatus: boolean;
+            bridgeCount: number;
+            bridgeEdgeCount: number;
+            bridgeIds: string[];
+            fromStatusIds: AgenticCodingPlanStepStatus[];
+            toStatusIds: AgenticCodingPlanStepStatus[];
+            tonePairs: Array<{
+                fromTone: 'neutral' | 'success' | 'warning' | 'danger';
+                id: string;
+                toTone: 'neutral' | 'success' | 'warning' | 'danger';
+            }>;
+        };
+        statusTransitionBridgeViewport?: {
+            bounds: {
+                height: number;
+                maxX: number;
+                maxY: number;
+                minX: number;
+                minY: number;
+                width: number;
+            };
+            bridgeCount: number;
+            bridgeEdgeCount: number;
+            bridgeIds: string[];
+            center: {
+                x: number;
+                y: number;
+            };
+            padding: number;
+        };
+        renderLayers: Array<{
+            id: 'status-regions' | 'status-bridges' | 'active-trail' | 'upcoming-trail' | 'focus-window' | 'focus-controls';
+            itemCount: number;
+            label: string;
+            mode: 'passive';
+            order: number;
+            safetyNote: string;
+            visible: boolean;
+        }>;
+        renderLayerSummary?: {
+            layerCount: number;
+            layerIds: Array<'status-regions' | 'status-bridges' | 'active-trail' | 'upcoming-trail' | 'focus-window' | 'focus-controls'>;
+            mode: 'passive';
+            safetyNote: string;
+            totalItemCount: number;
+            visibleLayerCount: number;
+            visibleLayerIds: Array<'status-regions' | 'status-bridges' | 'active-trail' | 'upcoming-trail' | 'focus-window' | 'focus-controls'>;
+        };
+        renderLayerSafety?: {
+            allLayersPassive: boolean;
+            canExecuteAny: false;
+            executableLayerCount: number;
+            layerCount: number;
+            mode: 'passive';
+            safetyNote: string;
+        };
+        renderLayerGroups: Array<{
+            id: 'regions' | 'paths' | 'focus';
+            label: string;
+            layerCount: number;
+            layerIds: Array<'status-regions' | 'status-bridges' | 'active-trail' | 'upcoming-trail' | 'focus-window' | 'focus-controls'>;
+            mode: 'passive';
+            order: number;
+            safetyNote: string;
+            totalItemCount: number;
+            visibleLayerCount: number;
+            visibleLayerIds: Array<'status-regions' | 'status-bridges' | 'active-trail' | 'upcoming-trail' | 'focus-window' | 'focus-controls'>;
+        }>;
+        renderLayerGroupSummary?: {
+            groupCount: number;
+            groupIds: Array<'regions' | 'paths' | 'focus'>;
+            mode: 'passive';
+            safetyNote: string;
+            totalItemCount: number;
+            visibleGroupCount: number;
+            visibleGroupIds: Array<'regions' | 'paths' | 'focus'>;
+        };
+        renderLayerGroupSafety?: {
+            allGroupsPassive: boolean;
+            canExecuteAny: false;
+            executableGroupCount: number;
+            groupCount: number;
+            mode: 'passive';
+            safetyNote: string;
+        };
+        renderLayerGroupBadges: Array<{
+            accessibilityLabel: string;
+            countLabel: string;
+            groupId: 'regions' | 'paths' | 'focus';
+            id: string;
+            itemCount: number;
+            label: string;
+            layerCount: number;
+            mode: 'passive';
+            safetyNote: string;
+            visible: boolean;
+            tone: 'neutral' | 'success' | 'warning' | 'danger';
+        }>;
+        renderLayerGroupBadgeSummary?: {
+            badgeCount: number;
+            badgeIds: string[];
+            countLabels: string[];
+            mode: 'passive';
+            safetyNote: string;
+            totalItemCount: number;
+            visibleBadgeCount: number;
+            visibleBadgeIds: string[];
+        };
+        renderLayerGroupBadgeAccessibilitySummary?: {
+            accessibilityLabels: string[];
+            badgeCount: number;
+            badgeIds: string[];
+            labelCount: number;
+            mode: 'passive';
+            safetyNote: string;
+        };
+        renderLayerGroupBadgeAccessibilityAudit?: {
+            allLabelsPresent: boolean;
+            badgeCount: number;
+            duplicateLabelCount: number;
+            duplicateLabels: string[];
+            labelCount: number;
+            missingLabelCount: number;
+            mode: 'passive';
+            safetyNote: string;
+        };
+        renderLayerGroupBadgeAccessibilityHealth?: {
+            badgeCount: number;
+            duplicateLabelCount: number;
+            labelCount: number;
+            missingLabelCount: number;
+            mode: 'passive';
+            safetyNote: string;
+            status: 'ready' | 'needs_attention';
+            summary: string;
+            tone: 'success' | 'warning';
+        };
+        renderLayerGroupBadgeAccessibilityChecklist?: Array<{
+            badgeCount: number;
+            id: 'labels-present' | 'labels-unique';
+            issueCount: number;
+            label: string;
+            mode: 'passive';
+            safetyNote: string;
+            status: 'ready' | 'needs_attention';
+            summary: string;
+            tone: 'success' | 'warning';
+        }>;
+        renderLayerGroupBadgeAccessibilityChecklistSummary?: {
+            badgeCount: number;
+            checkCount: number;
+            checkIds: Array<'labels-present' | 'labels-unique'>;
+            issueCount: number;
+            mode: 'passive';
+            needsAttentionCheckCount: number;
+            readyCheckCount: number;
+            safetyNote: string;
+            status: 'ready' | 'needs_attention';
+            tone: 'success' | 'warning';
+        };
+        renderLayerGroupBadgeSafety?: {
+            allBadgesPassive: boolean;
+            badgeCount: number;
+            canExecuteAny: false;
+            executableBadgeCount: number;
+            mode: 'passive';
+            safetyNote: string;
+        };
+        renderLayerGroupBadgeToneSummary?: {
+            badgeCount: number;
+            mode: 'passive';
+            safetyNote: string;
+            toneIds: Array<'neutral' | 'success' | 'warning' | 'danger'>;
+            tonePairs: Array<{
+                badgeId: string;
+                tone: 'neutral' | 'success' | 'warning' | 'danger';
+            }>;
+            uniqueToneCount: number;
+            uniqueToneIds: Array<'neutral' | 'success' | 'warning' | 'danger'>;
+        };
+        renderLayerGroupBadgeToneLegend?: Array<{
+            badgeCount: number;
+            badgeIds: string[];
+            id: string;
+            label: string;
+            mode: 'passive';
+            safetyNote: string;
+            tone: 'neutral' | 'success' | 'warning' | 'danger';
+        }>;
+        renderLayerGroupBadgeToneLegendSummary?: {
+            badgeCount: number;
+            labelIds: string[];
+            labels: string[];
+            legendCount: number;
+            mode: 'passive';
+            safetyNote: string;
+            toneIds: Array<'neutral' | 'success' | 'warning' | 'danger'>;
+        };
+        statusTransitionSummary?: {
+            crossStatusEdgeCount: number;
+            crossStatusTransitionCount: number;
+            crossStatusTransitionIds: string[];
+            sameStatusEdgeCount: number;
+            sameStatusTransitionCount: number;
+            sameStatusTransitionIds: string[];
+            totalEdgeCount: number;
+            trackedEdgeCount: number;
+            transitionCount: number;
+            untrackedEdgeCount: number;
+        };
+        focusWindowBounds?: {
+            height: number;
+            maxX: number;
+            maxY: number;
+            minX: number;
+            minY: number;
+            width: number;
+        };
+        focusWindowRange?: {
+            containsEnd: boolean;
+            containsStart: boolean;
+            endIndex: number;
+            nodeIds: string[];
+            size: number;
+            startIndex: number;
+            totalNodeCount: number;
+        };
+        focusWindowSegments: Array<{
+            edgeId: string;
+            source: string;
+            sourcePosition: {
+                x: number;
+                y: number;
+            };
+            target: string;
+            targetPosition: {
+                x: number;
+                y: number;
+            };
+        }>;
+        focusWindowStatuses: Array<{
+            count: number;
+            id: AgenticCodingPlanStepStatus;
+            label: string;
+            tone: 'neutral' | 'success' | 'warning' | 'danger';
+        }>;
+        focusWindowSummary?: {
+            currentIndex: number;
+            currentNodeId: string;
+            currentStatus: AgenticCodingPlanStepStatus;
+            currentTone: 'neutral' | 'success' | 'warning' | 'danger';
+            endIndex: number;
+            hasNext: boolean;
+            hasPrevious: boolean;
+            nodeIds: string[];
+            segmentCount: number;
+            startIndex: number;
+            statusIds: AgenticCodingPlanStepStatus[];
+            totalNodeCount: number;
+            windowNodeCount: number;
+        };
+        focusWindowControls: Array<{
+            actionType: 'focus_previous' | 'focus_current' | 'focus_next';
+            canExecute: false;
+            disabledReason?: 'no_previous_focus' | 'no_next_focus';
+            enabled: boolean;
+            executionMode: 'display_only';
+            id: 'previous' | 'current' | 'next';
+            isActive: boolean;
+            keyHint: 'ArrowUp' | 'Enter' | 'ArrowDown';
+            label: string;
+            safetyNote: string;
+            targetIndex?: number;
+            targetNodeId?: string;
+            targetPosition?: {
+                x: number;
+                y: number;
+            };
+            targetStatus?: AgenticCodingPlanStepStatus;
+            tone: 'neutral' | 'success' | 'warning' | 'danger';
+        }>;
+        focusWindowControlSummary?: {
+            activeControlId?: 'previous' | 'current' | 'next';
+            controlCount: number;
+            disabledControlIds: Array<'previous' | 'current' | 'next'>;
+            enabledControlIds: Array<'previous' | 'current' | 'next'>;
+            keyHints: Array<{
+                actionType: 'focus_previous' | 'focus_current' | 'focus_next';
+                id: 'previous' | 'current' | 'next';
+                keyHint: 'ArrowUp' | 'Enter' | 'ArrowDown';
+            }>;
+        };
+        focusWindowControlSafety?: {
+            allControlsDisplayOnly: boolean;
+            canExecuteAny: false;
+            controlCount: number;
+            displayOnlyControlCount: number;
+            executableControlCount: number;
+            executionMode: 'display_only';
+            safetyNote: string;
+        };
+        focusWindow?: {
+            current: {
+                id: string;
+                index: number;
+                position: {
+                    x: number;
+                    y: number;
+                };
+            };
+            hasNext: boolean;
+            hasPrevious: boolean;
+            next?: {
+                id: string;
+                index: number;
+                position: {
+                    x: number;
+                    y: number;
+                };
+            };
+            previous?: {
+                id: string;
+                index: number;
+                position: {
+                    x: number;
+                    y: number;
+                };
+            };
+        };
+        focusNodeIds: string[];
+        mode: 'passive';
+        nodeCount: number;
+        padding: number;
+        safetyNote: string;
+    };
+    guardrails: {
+        approvalState?: AgenticCodingApprovalState;
+        canRunCommand?: boolean;
+        commandCount: number;
+        disallowedActions: string[];
+        missingRequiredCount: number;
+        needsApprovalDecision: boolean;
+        needsHumanReview: boolean;
+        producerMode?: 'data_only_edit_proposal';
+        readOnlyTools: string[];
+        readyCommandCount: number;
+        requiredBeforeApply?: boolean;
+        safetyNotes: string[];
+        validationErrors: string[];
+    };
+    harness: {
+        activeState: {
+            activePanelId?: string;
+            activeStepId?: string;
+            approvalState?: AgenticCodingApprovalState;
+            canRunCommand?: boolean;
+            missingRequiredCount: number;
+            readyCommandCount: number;
+            recommendedPanelId?: string;
+            supervisionState: 'human_review_required' | 'ready_for_command' | 'blocked' | 'idle';
+            workspaceStatus: AgenticCodingProposalLoopCoworkWorkspaceStatus;
+        };
+        canExecute: false;
+        contractTerms: Array<{
+            authority: string;
+            definedBy: string;
+            id: 'run' | 'evidence' | 'sensitive-action' | 'workflow' | 'human-approval' | 'memory-or-lesson' | 'agent-boundary';
+            label: string;
+            safetyNote: string;
+        }>;
+        executionMode: 'display_only';
+        hermes: {
+            agentId: 'hermes';
+            dispatchProfile: string;
+            lifecycleStages: Array<{
+                blocksOperation: boolean;
+                coreTouchpoint: string;
+                label: string;
+                purpose: string;
+                stage: string;
+                userHookEvent: string;
+            }>;
+            nativeSurfaces: Array<{
+                codeBuddySurface: string;
+                id: string;
+                label: string;
+                purpose: string;
+            }>;
+            operatingRules: string[];
+            toolsetId: string;
+        };
+        kind: 'agentic-coding-harness-contract';
+        label: 'Harness / security and orchestration contract';
+        mode: 'passive';
+        objective: string;
+        safetyNotes: string[];
+        schemaVersion: 1;
+    };
+    manifest?: {
+        artifactPath: string;
+        coworkImport?: {
+            defaultPanelId?: string;
+            panelCount: number;
+            queueArtifactPath?: string;
+            requiredArtifactCount: number;
+            suggestedFocusPanelId?: string;
+        };
+        exists: boolean;
+        materialized: Array<{
+            path: string;
+            role: string;
+            safety: string;
+        }>;
+        materializedCount: number;
+        resolvedArtifactPath: string;
+        roles: string[];
+        source?: {
+            activeStepId?: string;
+            approvalState?: AgenticCodingApprovalState;
+            status?: AgenticCodingRunStatus;
+        };
+        validationErrors: string[];
+    };
+    producer?: {
+        request?: {
+            artifactPath: string;
+            editProposalFile?: string;
+            exists: boolean;
+            instructionCount: number;
+            instructions: string[];
+            proposalPromptFile?: string;
+            resolvedArtifactPath: string;
+            safety: string[];
+            safetyCount: number;
+            schemaKeys: string[];
+            sourceActiveStepId?: string;
+            status?: AgenticCodingRunStatus;
+            taskFile?: string;
+            validationErrors: string[];
+        };
+        dispatch?: {
+            allowedTools: string[];
+            artifactPath: string;
+            disallowedActions: string[];
+            editProposalFile?: string;
+            exists: boolean;
+            maxToolRounds?: number;
+            mode?: 'data_only_edit_proposal';
+            resolvedArtifactPath: string;
+            reviewCommand?: AgenticCodingProposalLoopCommand;
+            sourceActiveStepId?: string;
+            validationErrors: string[];
+        };
+        review?: {
+            affectedFiles: string[];
+            artifactPath: string;
+            editSummary?: {
+                declared: number;
+                producer?: string;
+                proposed?: number;
+                summary?: string;
+            };
+            exists: boolean;
+            nextAction?: AgenticCodingEditProposalReviewSnapshot['nextAction'];
+            reason?: string;
+            resolvedArtifactPath: string;
+            sourceProposalFile?: string;
+            state?: AgenticCodingEditProposalReviewState;
+            validationErrors: string[];
+        };
+        validationErrors: string[];
+    };
+    actionRail: {
+        actions: Array<{
+            badgeIds: string[];
+            disabledReason?: string;
+            enabled: boolean;
+            id: 'open-active-panel' | 'fill-approval-decision' | 'inspect-guardrails' | 'copy-next-command';
+            label: string;
+            panelId?: string;
+            safetyNote: string;
+            type: 'open_panel' | 'fill_form' | 'copy_command';
+        }>;
+        mode: 'passive';
+        primaryActionId?: string;
+    };
+    artifactShelf: {
+        availableArtifactCount: number;
+        groups: Array<{
+            availableArtifactCount: number;
+            id: 'workflow-map' | 'operator-review' | 'producer-handoff' | 'evidence-strip';
+            label: string;
+            panelIds: string[];
+            primaryArtifactPath?: string;
+            primaryPanelId?: string;
+            requiredArtifactCount: number;
+            totalArtifactCount: number;
+            unavailableArtifactCount: number;
+        }>;
+        missingRequiredCount: number;
+        mode: 'passive';
+        requiredArtifactCount: number;
+        totalArtifactCount: number;
+    };
+    availablePanelIds: string[];
+    badges: Array<{
+        detail?: string;
+        id: string;
+        label: string;
+        tone: 'neutral' | 'success' | 'warning' | 'danger';
+        value: string;
+    }>;
+    defaultPanelId?: string;
+    decisionForm: {
+        affectedFiles: string[];
+        allowedDecisions: Array<'approved' | 'rejected'>;
+        artifactKind: 'agentic-coding-approval-decision';
+        defaultDecision: 'rejected';
+        panelId: 'approval';
+        reason: string;
+        required: boolean;
+        requiredFields: Array<'kind' | 'reviewer' | 'decision' | 'reason'>;
+        safetyNotes: string[];
+    };
+    focus: {
+        activeBadgeIds: string[];
+        activePanelId?: string;
+        activeRegionId?: 'workflow-map' | 'operator-review' | 'producer-handoff' | 'evidence-strip';
+        reason: string;
+        recommendedPanelId?: string;
+        supervisionState: 'human_review_required' | 'ready_for_command' | 'blocked' | 'idle';
+    };
+    generatedAt: string;
+    kind: 'agentic-coding-proposal-loop-cowork-workspace';
+    missingRequiredArtifactPaths: string[];
+    navigation: {
+        activePanelId?: string;
+        availableCount: number;
+        defaultPanelId?: string;
+        groups: Array<{
+            availablePanelIds: string[];
+            id: 'workflow' | 'review' | 'producer' | 'evidence';
+            label: string;
+            panelIds: string[];
+            unavailablePanelIds: string[];
+        }>;
+        missingRequiredCount: number;
+        panelCount: number;
+        recommendedPanelId?: string;
+        requiredCount: number;
+        tabs: Array<{
+            active: boolean;
+            available: boolean;
+            disabledReason?: string;
+            id: string;
+            recommended: boolean;
+            required: boolean;
+            title: string;
+            view: AgenticCodingProposalLoopCoworkPanelView;
+        }>;
+    };
+    layout: {
+        badgeStrip: {
+            badgeIds: string[];
+            placement: 'top';
+        };
+        density: 'compact';
+        regions: Array<{
+            active: boolean;
+            availablePanelIds: string[];
+            id: 'workflow-map' | 'operator-review' | 'producer-handoff' | 'evidence-strip';
+            label: string;
+            panelIds: string[];
+            primaryPanelId?: string;
+            required: boolean;
+            unavailablePanelIds: string[];
+        }>;
+    };
+    openPanelId?: string;
+    operatorBrief: {
+        body: string;
+        evidence: string[];
+        headline: string;
+        nextActionId?: AgenticCodingProposalLoopCoworkWorkspace['actionRail']['actions'][number]['id'];
+        panelId?: string;
+        severity: 'info' | 'success' | 'warning' | 'danger';
+        state: AgenticCodingProposalLoopCoworkWorkspace['supervision']['state'];
+    };
+    operatorHandoff: {
+        actionId?: AgenticCodingProposalLoopCoworkWorkspace['actionRail']['actions'][number]['id'];
+        artifactPath?: string;
+        evidence: string[];
+        mode: 'passive';
+        panelId?: string;
+        regionId?: 'workflow-map' | 'operator-review' | 'producer-handoff' | 'evidence-strip';
+        required: boolean;
+        safetyNotes: string[];
+        state: AgenticCodingProposalLoopCoworkWorkspace['supervision']['state'];
+        summary: string;
+        title: string;
+    };
+    panels: Array<{
+        artifactPath: string;
+        available: boolean;
+        id: string;
+        required: boolean;
+        resolvedArtifactPath: string;
+        role: string;
+        title: string;
+        view: AgenticCodingProposalLoopCoworkPanelView;
+    }>;
+    panelStates: Array<{
+        active: boolean;
+        attentionBadgeIds: string[];
+        attentionTone: 'neutral' | 'warning' | 'danger';
+        available: boolean;
+        disabledReason?: string;
+        id: string;
+        recommended: boolean;
+        regionId?: 'workflow-map' | 'operator-review' | 'producer-handoff' | 'evidence-strip';
+        required: boolean;
+        title: string;
+        view: AgenticCodingProposalLoopCoworkPanelView;
+    }>;
+    queue?: {
+        activeStepId?: string;
+        artifactPath: string;
+        canRunCommand?: boolean;
+        exists: boolean;
+        nextActionType?: AgenticCodingProposalLoopNextActionType;
+        resolvedArtifactPath: string;
+        runState?: AgenticCodingProposalLoopRunState;
+        uiPrimaryAction?: AgenticCodingProposalLoopNextActionUi['primaryAction'];
+        validationErrors: string[];
+    };
+    reviewChecklist: {
+        affectedFiles: string[];
+        items: Array<{
+            id: string;
+            label: string;
+            panelId?: string;
+            status: 'pending' | 'completed' | 'blocked';
+        }>;
+        nextItemId?: string;
+        required: boolean;
+        status: 'pending' | 'completed' | 'blocked';
+    };
+    reviewRoute: {
+        mode: 'passive';
+        nextStepId?: string;
+        required: boolean;
+        steps: Array<{
+            actionId?: AgenticCodingProposalLoopCoworkWorkspace['actionRail']['actions'][number]['id'];
+            active: boolean;
+            artifactPath?: string;
+            id: string;
+            label: string;
+            panelId?: string;
+            regionId?: 'workflow-map' | 'operator-review' | 'producer-handoff' | 'evidence-strip';
+            safetyNote: string;
+            status: 'pending' | 'completed' | 'blocked';
+        }>;
+    };
+    schemaVersion: 1;
+    source: {
+        checkStatus: AgenticCodingProposalLoopCoworkImportCheckStatus;
+        importFile: string;
+        summary?: string;
+    };
+    status: AgenticCodingProposalLoopCoworkWorkspaceStatus;
+    supervision: {
+        actionType?: string;
+        approvalState?: AgenticCodingApprovalState;
+        panelId?: string;
+        producerReviewState?: AgenticCodingEditProposalReviewState;
+        reason: string;
+        required: boolean;
+        state: 'human_review_required' | 'ready_for_command' | 'blocked' | 'idle';
+        stepId?: string;
+    };
+    stepper?: {
+        activeStepId?: string;
+        artifactPath: string;
+        blockedStepIds: string[];
+        completedStepIds: string[];
+        counts: AgenticCodingProposalLoopSnapshot['counts'];
+        exists: boolean;
+        resolvedArtifactPath: string;
+        steps: Array<{
+            active: boolean;
+            id: string;
+            label: string;
+            status: AgenticCodingPlanStepStatus;
+        }>;
+        validationErrors: string[];
+    };
+    suggestedFocusPanelId?: string;
+    ui: {
+        primaryAction: {
+            disabledReason?: string;
+            enabled: boolean;
+            label: string;
+            panelId?: string;
+            type: AgenticCodingProposalLoopCoworkWorkspaceActionType;
+        };
+        statusText: string;
+    };
+    unavailablePanelIds: string[];
+}
+type AgenticCodingProposalLoopCoworkWorkspaceQueue = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['queue']>;
+type AgenticCodingProposalLoopCoworkWorkspaceStepper = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['stepper']>;
+type AgenticCodingProposalLoopCoworkWorkspaceActivity = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['activity']>;
+type AgenticCodingProposalLoopCoworkWorkspaceApproval = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['approval']>;
+type AgenticCodingProposalLoopCoworkWorkspaceCommands = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['commands']>;
+type AgenticCodingProposalLoopCoworkWorkspaceEvidence = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['evidence']>;
+type AgenticCodingProposalLoopCoworkWorkspaceGraph = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['graph']>;
+type AgenticCodingProposalLoopCoworkWorkspaceManifest = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['manifest']>;
+type AgenticCodingProposalLoopCoworkWorkspaceProducer = NonNullable<AgenticCodingProposalLoopCoworkWorkspace['producer']>;
+export interface AgenticCodingProposalLoopEvent {
+    active: boolean;
+    id: string;
+    message: string;
+    sequence: number;
+    severity: AgenticCodingWorkflowEventSeverity;
+    status: AgenticCodingPlanStepStatus;
+    stepId: string;
+}
+export interface AgenticCodingProposalLoopSnapshot {
+    activeStepId?: string;
+    artifacts: AgenticCodingProposalLoopArtifacts;
+    blockedStepIds: string[];
+    completedStepIds: string[];
+    counts: {
+        blocked: number;
+        completed: number;
+        pending: number;
+        ready: number;
+        skipped: number;
+        total: number;
+    };
+    edges: AgenticCodingWorkflowEdge[];
+    events: AgenticCodingProposalLoopEvent[];
+    generatedAt: string;
+    kind: 'agentic-coding-proposal-loop';
+    nextAction: {
+        message: string;
+        stepId?: string;
+        type: AgenticCodingProposalLoopNextActionType;
+    };
+    nodes: AgenticCodingWorkflowNode[];
+    prompts: {
+        approvalDecision: string;
+        editProposal: string;
+    };
+    schemaVersion: 1;
+    source: {
+        activeNodeId?: string;
+        approvalState: AgenticCodingApprovalState;
+        fleetMode: AgenticCodingFleetCollaborationMode;
+        fleetPolicy: AgenticCodingTaskContract['fleetPolicy'];
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+    steps: AgenticCodingProposalLoopStep[];
+}
+export interface AgenticCodingProposalLoopCanvas {
+    activeNodeId?: string;
+    blockedNodeIds: string[];
+    completedNodeIds: string[];
+    edges: AgenticCodingWorkflowCanvasEdge[];
+    generatedAt: string;
+    kind: 'agentic-coding-proposal-loop-canvas';
+    nodes: AgenticCodingWorkflowCanvasNode[];
+    schemaVersion: 1;
+    source: {
+        activeStepId?: string;
+        approvalState: AgenticCodingApprovalState;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+}
+export type AgenticCodingProposalLoopRunState = 'ready_command' | 'human_input_required' | 'blocked' | 'pending';
+export type AgenticCodingProposalLoopUiActionType = 'run_command' | 'human_review' | 'inspect_blocker' | 'wait';
+export interface AgenticCodingProposalLoopNextActionUi {
+    artifactHints: {
+        inputArtifacts: string[];
+        outputArtifacts: string[];
+    };
+    primaryAction: {
+        commandText?: string;
+        disabledReason?: string;
+        enabled: boolean;
+        label: string;
+        type: AgenticCodingProposalLoopUiActionType;
+    };
+    statusText: string;
+}
+export interface AgenticCodingProposalLoopNextActionSnapshot {
+    activeStep?: {
+        command?: AgenticCodingProposalLoopCommand;
+        id: string;
+        inputArtifacts: string[];
+        label: string;
+        outputArtifacts: string[];
+        safety: string[];
+        status: AgenticCodingPlanStepStatus;
+    };
+    artifacts: AgenticCodingProposalLoopArtifacts;
+    canRunCommand: boolean;
+    counts: AgenticCodingProposalLoopSnapshot['counts'];
+    generatedAt: string;
+    kind: 'agentic-coding-proposal-loop-next-action';
+    nextAction: AgenticCodingProposalLoopSnapshot['nextAction'];
+    runState: AgenticCodingProposalLoopRunState;
+    schemaVersion: 1;
+    source: {
+        activeStepId?: string;
+        approvalState: AgenticCodingApprovalState;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+    ui: AgenticCodingProposalLoopNextActionUi;
+}
+export interface AgenticCodingEditProposalRequest {
+    generatedAt: string;
+    input: {
+        proposalPromptFile: string;
+        taskFile: string;
+    };
+    instructions: string[];
+    kind: 'agentic-coding-edit-proposal-request';
+    output: {
+        editProposalFile: string;
+        schema: Record<string, unknown>;
+    };
+    safety: string[];
+    schemaVersion: 1;
+    source: {
+        activeStepId?: string;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+}
+export type AgenticCodingFleetCollaborationMode = 'disabled' | 'read_only_help' | 'data_only_delegated_slices';
+export interface AgenticCodingFleetCollaborationPlan {
+    allowedTools: string[];
+    chainRoles: FleetDispatchProfile[];
+    invocation?: {
+        args: {
+            chainRoles: FleetDispatchProfile[];
+            privacyTag: 'sensitive' | 'public';
+            prompt: string;
+            stageTimeoutMs: number;
+        };
+        tool: 'peer_chain';
+    };
+    mode: AgenticCodingFleetCollaborationMode;
+    policy: AgenticCodingTaskContract['fleetPolicy'];
+    safety: string[];
+}
+export interface AgenticCodingEditProposalProducerDispatch {
+    allowedTools: string[];
+    currentState: {
+        activeStepId?: string;
+        approvalState: AgenticCodingApprovalState;
+        workflow: AgenticCodingWorkflowReport;
+    };
+    disallowedActions: string[];
+    generatedAt: string;
+    input: {
+        proposalPromptFile: string;
+        repo: string;
+        taskFile: string;
+    };
+    fleet?: AgenticCodingFleetCollaborationPlan;
+    kind: 'agentic-coding-edit-proposal-producer-dispatch';
+    messages: Array<{
+        content: string;
+        role: 'system' | 'user';
+    }>;
+    output: {
+        editProposalFile: string;
+        reviewCommand: AgenticCodingProposalLoopCommand;
+        schema: Record<string, unknown>;
+    };
+    runPolicy: {
+        cwd: string;
+        maxToolRounds: number;
+        mode: 'data_only_edit_proposal';
+    };
+    safety: string[];
+    schemaVersion: 1;
+    source: {
+        activeStepId?: string;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+}
+export interface AgenticCodingProposalLoopArtifactBundle {
+    artifacts: AgenticCodingProposalLoopArtifactBundlePaths;
+    coworkImport: AgenticCodingProposalLoopCoworkImport;
+    generatedAt: string;
+    kind: 'agentic-coding-proposal-loop-artifact-bundle';
+    materialized: AgenticCodingProposalLoopMaterializedArtifact[];
+    schemaVersion: 1;
+    source: {
+        activeStepId?: string;
+        approvalState: AgenticCodingApprovalState;
+        repo: string;
+        status: AgenticCodingRunStatus;
+        taskFile: string;
+    };
+}
+export interface AgenticCodingRunReport {
+    approval: AgenticCodingApprovalReport;
+    approvalDecision?: AgenticCodingApprovalDecisionReport;
+    autoExecutable: boolean;
+    blockedReasons: string[];
+    contract?: AgenticCodingTaskContract;
+    dirtyFiles: AgenticCodingDirtyFile[];
+    editProposal?: AgenticCodingEditProposalReport;
+    editPreviewRequired: boolean;
+    editPreviewRequested: boolean;
+    editPreviews: AgenticCodingEditPreview[];
+    editRequested: boolean;
+    editResults: AgenticCodingEditResult[];
+    executionGate?: AgenticCodingExecutionGate;
+    fleet: AgenticCodingFleetCollaborationPlan;
+    generatedAt: string;
+    gitStatus?: string;
+    repo: string;
+    rulesFiles: AgenticCodingRulesFile[];
+    plan: AgenticCodingPlanStep[];
+    observability?: AgenticCodingObservabilityReport;
+    status: AgenticCodingRunStatus;
+    taskFile: string;
+    validationErrors: string[];
+    verification: AgenticCodingVerificationResult[];
+    verificationRequested: boolean;
+    workflow: AgenticCodingWorkflowReport;
+    workflowBuilderProposal?: AgenticCodingWorkflowBuilderProposalReport;
+    gitnexusEvidence?: GitNexusContext;
+    worldModelInvariants?: WorldModelInvariants | null;
+}
+export interface AgenticCodingObservabilityReport {
+    artifacts: {
+        progress?: string;
+        report?: string;
+    };
+    eventsPath: string;
+    runId: string;
+    runsDir: string;
+}
+export interface AgenticCodingEditProposalPromptOptions {
+    includeDirtyFiles?: boolean;
+}
+export interface AgenticCodingWorkflowBuilderPromptOptions {
+    includeCurrentCanvas?: boolean;
+}
+export declare function buildAgenticCodingProposalLoopCanvas(loop: AgenticCodingProposalLoopSnapshot): AgenticCodingProposalLoopCanvas;
+export declare function buildAgenticCodingWorkflowCanvas(report: AgenticCodingRunReport): AgenticCodingWorkflowCanvas;
+export declare function buildAgenticCodingWorkflowBuilderProposalCanvas(report: AgenticCodingRunReport): AgenticCodingWorkflowBuilderProposalCanvas | undefined;
+export declare function buildAgenticCodingWorkflowProgressSnapshot(report: AgenticCodingRunReport): AgenticCodingWorkflowProgressSnapshot;
+export declare function buildAgenticCodingWorkflowEventsSnapshot(report: AgenticCodingRunReport): AgenticCodingWorkflowEventsSnapshot;
+export declare function deriveAgenticCodingProposalLoopArtifacts(proposalLoopFile: string): AgenticCodingProposalLoopArtifacts;
+export declare function buildAgenticCodingProposalLoopSnapshot(report: AgenticCodingRunReport, artifacts: AgenticCodingProposalLoopArtifacts): AgenticCodingProposalLoopSnapshot;
+export declare function buildAgenticCodingEditProposalRequest(report: AgenticCodingRunReport, artifacts: AgenticCodingProposalLoopArtifactBundlePaths): AgenticCodingEditProposalRequest;
+export declare function buildAgenticCodingEditProposalProducerDispatch(report: AgenticCodingRunReport, artifacts: AgenticCodingProposalLoopArtifacts): AgenticCodingEditProposalProducerDispatch;
+export declare function buildAgenticCodingProposalLoopNextActionSnapshot(report: AgenticCodingRunReport, artifacts: AgenticCodingProposalLoopArtifacts): AgenticCodingProposalLoopNextActionSnapshot;
+export declare function buildAgenticCodingProposalLoopCoworkImport(report: AgenticCodingRunReport, artifacts: AgenticCodingProposalLoopArtifactBundlePaths): AgenticCodingProposalLoopCoworkImport;
+export declare function buildAgenticCodingProposalLoopArtifactBundle(report: AgenticCodingRunReport, artifacts: AgenticCodingProposalLoopArtifactBundlePaths): AgenticCodingProposalLoopArtifactBundle;
+export declare function aggregateReports(reports: AgenticCodingRunReport[], originalContract: AgenticCodingTaskContract, options: AgenticCodingRunOptions, status: AgenticCodingRunStatus): AgenticCodingRunReport;
+export declare function buildFinalReport(checkpoint: AgenticCodingCheckpoint): AgenticCodingRunReport;
+export declare function runDecomposedSubtasks(contract: AgenticCodingTaskContract, options: AgenticCodingRunOptions, subtasks: AgenticCodingTaskContract[], startIndex?: number, existingReports?: AgenticCodingRunReport[]): Promise<AgenticCodingRunReport>;
+export declare function runAgenticCodingCell(options: AgenticCodingRunOptions): Promise<AgenticCodingRunReport>;
+export declare function buildAgenticCodingApprovalSnapshot(report: AgenticCodingRunReport): AgenticCodingApprovalSnapshot;
+export declare function buildAgenticCodingEditProposalReviewSnapshot(report: AgenticCodingRunReport): AgenticCodingEditProposalReviewSnapshot;
+export declare function renderAgenticCodingRunReport(report: AgenticCodingRunReport): string;
+export declare function writeAgenticCodingRunReport(report: AgenticCodingRunReport, reportFile: string): Promise<string>;
+export declare function writeAgenticCodingApprovalSnapshot(report: AgenticCodingRunReport, approvalFile: string): Promise<string>;
+export declare function writeAgenticCodingEditProposalReviewSnapshot(report: AgenticCodingRunReport, editProposalReviewFile: string): Promise<string>;
+export declare function writeAgenticCodingWorkflowCanvas(report: AgenticCodingRunReport, workflowFile: string): Promise<string>;
+export declare function writeAgenticCodingWorkflowBuilderProposalCanvas(report: AgenticCodingRunReport, workflowBuilderProposalCanvasFile: string): Promise<string>;
+export declare function writeAgenticCodingWorkflowProgressSnapshot(report: AgenticCodingRunReport, workflowProgressFile: string): Promise<string>;
+export declare function writeAgenticCodingWorkflowEventsSnapshot(report: AgenticCodingRunReport, workflowEventsFile: string): Promise<string>;
+export declare function writeAgenticCodingProposalLoopSnapshot(report: AgenticCodingRunReport, proposalLoopFile: string): Promise<string>;
+export declare function writeAgenticCodingProposalLoopCanvas(report: AgenticCodingRunReport, proposalLoopCanvasFile: string): Promise<string>;
+export declare function writeAgenticCodingProposalLoopNextActionSnapshot(report: AgenticCodingRunReport, proposalLoopNextActionFile: string): Promise<string>;
+export declare function writeAgenticCodingEditProposalProducerDispatch(report: AgenticCodingRunReport, editProposalProducerDispatchFile: string): Promise<string>;
+export declare function writeAgenticCodingProposalLoopArtifactBundle(report: AgenticCodingRunReport, proposalLoopArtifactsDir: string): Promise<string>;
+export declare function writeAgenticCodingProposalLoopCoworkImport(report: AgenticCodingRunReport, proposalLoopCoworkImportFile: string): Promise<string>;
+export declare function buildAgenticCodingProposalLoopCoworkImportCheck(proposalLoopCoworkImportFile: string): Promise<AgenticCodingProposalLoopCoworkImportCheck>;
+export declare function buildAgenticCodingProposalLoopCoworkWorkspace(check: AgenticCodingProposalLoopCoworkImportCheck, queue?: AgenticCodingProposalLoopCoworkWorkspaceQueue, stepper?: AgenticCodingProposalLoopCoworkWorkspaceStepper, activity?: AgenticCodingProposalLoopCoworkWorkspaceActivity, approval?: AgenticCodingProposalLoopCoworkWorkspaceApproval, commands?: AgenticCodingProposalLoopCoworkWorkspaceCommands, graph?: AgenticCodingProposalLoopCoworkWorkspaceGraph, producer?: AgenticCodingProposalLoopCoworkWorkspaceProducer, evidence?: AgenticCodingProposalLoopCoworkWorkspaceEvidence, manifest?: AgenticCodingProposalLoopCoworkWorkspaceManifest): AgenticCodingProposalLoopCoworkWorkspace;
+export declare function writeAgenticCodingProposalLoopCoworkImportCheck(proposalLoopCoworkImportFile: string, proposalLoopCoworkImportCheckFile: string): Promise<string>;
+export declare function writeAgenticCodingProposalLoopCoworkWorkspace(proposalLoopCoworkImportFile: string, proposalLoopCoworkWorkspaceFile: string): Promise<string>;
+export declare function renderAgenticCodingApprovalDecisionPrompt(report: AgenticCodingRunReport): string;
+export declare function renderAgenticCodingWorkflowBuilderPrompt(report: AgenticCodingRunReport, options?: AgenticCodingWorkflowBuilderPromptOptions): string;
+export declare function renderAgenticCodingEditProposalPrompt(report: AgenticCodingRunReport, options?: AgenticCodingEditProposalPromptOptions): string;
+export declare function writeAgenticCodingEditProposalPrompt(report: AgenticCodingRunReport, proposalPromptFile: string, options?: AgenticCodingEditProposalPromptOptions): Promise<string>;
+export declare function writeAgenticCodingApprovalDecisionPrompt(report: AgenticCodingRunReport, approvalDecisionPromptFile: string): Promise<string>;
+export declare function writeAgenticCodingWorkflowBuilderPrompt(report: AgenticCodingRunReport, workflowBuilderPromptFile: string, options?: AgenticCodingWorkflowBuilderPromptOptions): Promise<string>;