@vypdev/copilot 3.10.6 → 3.10.8

package/build/api/src/application/ports/agent_findings_ports.d.ts

@@ -1,7 +1,11 @@
 import type { AgentQueryRequest, AgentQueryResult } from './agent_query_ports';
+import type { AgentSourceSnapshot } from '../../domain/agent_source_snapshot';
 export type { AgentQueryOptions } from './agent_query_ports';
 export interface FindingsQueryRequest extends AgentQueryRequest {
     agentId: string;
+    readonly signal?: AbortSignal;
+    /** Host-selected immutable source for pre-branch SDD queries; never a cwd input. */
+    readonly sourceSnapshot?: AgentSourceSnapshot;
 }
 export interface FindingsQueryPort {
     query(request: FindingsQueryRequest): Promise<AgentQueryResult>;

package/build/api/src/application/ports/bugbot_context_ports.d.ts

@@ -8,12 +8,13 @@ export interface BoundedBugbotRead<T> {
     readonly coverage: BugbotSourceCoverage;
 }
 export interface BoundBugbotContextReadPorts {
+    getSourceBoundPullRequest?(pullRequestNumber: number): Promise<BugbotPullRequestIdentity>;
     getPullRequest(pullRequestNumber: number): Promise<BugbotPullRequestIdentity>;
     findOpenPullRequestsByExactHead(headOwner: string, headRef: string): Promise<readonly BugbotPullRequestIdentity[]>;
     listIssueComments(issueNumber: number): Promise<BoundedBugbotRead<readonly BugbotIssueComment[]>>;
     listPullRequestReviewComments(pullRequestNumber: number): Promise<BoundedBugbotRead<readonly PullRequestReviewComment[]>>;
     listPullRequestReviewThreadStates(pullRequestNumber: number): Promise<BoundedBugbotRead<Readonly<Record<string, PullRequestReviewThreadState>>>>;
-    getReviewDiffSnapshot(pullRequestNumber: number): Promise<BoundedBugbotRead<PullRequestReviewDiffSnapshot>>;
+    getReviewDiffSnapshot(pullRequestNumber: number, expectedHeadSha?: string): Promise<BoundedBugbotRead<PullRequestReviewDiffSnapshot>>;
     getPullRequestHeadSha(pullRequestNumber: number): Promise<string | undefined>;
     getPullRequestReviewCommentBody(pullRequestNumber: number, commentId: number): Promise<string | null>;
     loadRules(paths: readonly string[], revision?: string): ReturnType<BugbotRuleFileQueryPort['loadRules']>;

package/build/api/src/application/ports/bugbot_pull_request_read_ports.d.ts

@@ -4,6 +4,7 @@ export interface PullRequestDiffLocation {
     side: "LEFT" | "RIGHT";
 }
 export interface PullRequestReviewChange {
+    readonly previousFilename?: string;
     filename: string;
     status: string;
     additions: number;

package/build/api/src/application/ports/bugbot_review_source_ports.d.ts

@@ -0,0 +1,7 @@
+import type { BugbotPullRequestIdentity } from '../../domain/bugbot/context';
+import type { BugbotFramedReviewSource } from '../../domain/bugbot/framed_review';
+import type { PullRequestReviewDiffSnapshot } from './bugbot_pull_request_read_ports';
+/** Fixed, read-only host capability. No process, filesystem-write or credential authority escapes. */
+export interface BugbotReviewSourcePort {
+    readCompleteSource(identity: BugbotPullRequestIdentity, snapshot: PullRequestReviewDiffSnapshot, enumerationComplete: boolean, ignorePatterns: readonly string[]): Promise<BugbotFramedReviewSource>;
+}

package/build/api/src/application/ports/bugbot_scm_ports.d.ts

@@ -1,9 +1,11 @@
+import type { BugbotReviewSourcePort } from './bugbot_review_source_ports';
 import type { BugbotContextPorts } from './bugbot_context_ports';
 import type { BugbotFindingPublicationPorts } from './bugbot_finding_publication_ports';
 import type { BugbotFindingResolutionPorts } from './bugbot_finding_resolution_ports';
 import type { BugbotPresentationMutationPorts, BugbotReconciliationSnapshotPorts } from './bugbot_reconciliation_ports';
 /** Complete repository-bound SCM surface consumed by one Bugbot review. */
 export interface BugbotScmPorts {
+    readonly reviewSource?: BugbotReviewSourcePort;
     readonly context: BugbotContextPorts;
     readonly publication: BugbotFindingPublicationPorts;
     readonly resolution: BugbotFindingResolutionPorts;

package/build/api/src/application/ports/bugbot_telemetry_ports.d.ts

@@ -37,6 +37,17 @@ export interface BugbotReviewTelemetrySnapshot {
     readonly contextLogicalProviderReads: number;
     readonly contextRawProviderRequests: number;
     readonly contextConcurrencyLimit: 2;
+    readonly framedReview?: {
+        readonly profile: 'framed-v1';
+        readonly frames: number;
+        readonly completedFrames: number;
+        readonly manifestDigest: string;
+        readonly rawUtf16: number;
+        readonly renderedUtf16: number;
+        readonly promptBytes: number;
+        readonly responseBytes: number;
+        readonly source?: import('../../domain/bugbot/framed_review').BugbotFramedReviewSource['metrics'];
+    };
     readonly analysisPartitions?: number;
     readonly completedAnalysisPartitions?: number;
     readonly analysisDiffFragments?: number;

package/build/api/src/data/model/application_error.d.ts

@@ -1,15 +1,27 @@
+import { type BranchSyncPublicationDiagnostic } from '../../domain/branch_sync_publication';
+import { type BugbotReviewBlockFacts } from '../../domain/bugbot/framed_review';
+import { type ProgressScopeCapacityFacts } from '../../domain/progress_response_diagnostic';
+import { type ProgressCompletionDiagnostic } from '../../domain/progress_completion_diagnostic';
+import { type ProgressInventoryDiagnostic } from '../../domain/progress_inventory_diagnostic';
+import { type ProgressCapacityDiagnostic } from '../../domain/progress_capacity_diagnostic';
+import { type ProgressResponseDiagnosticFacts } from '../../domain/progress_response_diagnostic';
+import { type ProgressPartitionLengthDiagnostic } from '../../domain/progress_partition_length_failure';
 import { type ProgressBinaryEvidenceFacts } from '../../domain/progress_binary_evidence_diagnostic';
 import { type IssueWorkflowDiagnosticFacts } from '../../domain/issue_workflow_diagnostic';
 import { type ChangeSizeReconciliationFacts } from '../../domain/change_size_reconciliation';
+import { type IssueAssignmentDiagnostic } from '../../domain/issue_assignment_diagnostic';
 import { type CopilotCommandValidationReason } from '../../domain/copilot_command_validation';
 import type { CopilotCommandName } from '../../domain/copilot_command';
 import { type ClosedIssueReconciliationFacts } from '../../domain/closed_issue_reconciliation';
 import { type ApprovalEvidenceDiagnostic } from '../../domain/approval_evidence_diagnostic';
 import { type BranchSyncValidationCode } from '../../domain/branch_sync_validation';
 import { type BranchSyncVerificationFailure } from '../../domain/verification_failure';
+import { type BranchSyncCatalogDiagnostic } from '../../domain/branch_sync_catalog_diagnostic';
+import { type SddSourceContextDiagnostic } from '../../domain/agent_source_snapshot';
+import { type SddDraftMinimumDiagnostic } from '../../domain/sdd_validation_diagnostic';
 export type ApplicationErrorKind = 'configuration' | 'authorization' | 'provider' | 'agent' | 'validation' | 'workflow' | 'unknown';
 export type ApplicationErrorCode = 'configuration.invalid' | 'configuration.unsupported' | 'authorization.denied' | 'authorization.credential-invalid' | 'provider.not-found' | 'provider.conflict' | 'provider.rate-limited' | 'provider.unavailable' | 'provider.contract-invalid' | 'agent.policy-rejected' | 'agent.failed' | 'locale.output-invalid' | 'locale.translation-failed' | 'validation.invalid-input' | 'validation.evidence-too-large' | 'validation.evidence-unavailable' | 'workflow.invalid-event' | 'workflow.stale' | 'workflow.cancelled' | 'workflow.failed' | 'workflow.presentation-pending' | 'timeout' | 'unexpected';
-export declare const APPLICATION_ERROR_RECOVERY_IDS: readonly ["comment-command-length", "comment-command-name-missing", "comment-command-name-unknown", "comment-command-argument-count", "comment-command-arguments-unexpected", "comment-command-arguments-missing", "comment-command-finding-quoting", "comment-command-review-format", "comment-command-review-effort", "comment-command-review-boolean", "comment-command-review-option", "comment-command-sync-option", "comment-command-sync-parent", "pull-request-link-restored", "pull-request-link-base-retained", "pull-request-link-reference-retained", "pull-request-link-base-and-reference-retained", "managed-branch-enrichment-failed", "inactivity-explanation-failed", "bugbot-review-blocks-pending", "branch-sync-agent-disabled", "branch-sync-fixer-unavailable", "branch-sync-resolution-invalid", "branch-sync-verification-failed", "sdd-draft-size-exceeded", "sdd-catalog-unsupported-profile", "sdd-catalog-format-invalid", "sdd-draft-format-invalid", "sdd-draft-case-identity-invalid", "sdd-draft-case-budget-invalid", "sdd-draft-requirement-mapping-invalid", "sdd-draft-repository-path-invalid", "deployment-publication-context-missing", "workspace-changes-rejected", "closed-issue-reconciliation-failed", "approval-evidence-read-failed", "change-size-reconciliation-failed", "issue-workflow-admission-blocked", "progress-binary-evidence-unavailable", "stored-configuration-schema-missing", "stored-configuration-schema-unsupported", "stored-configuration-invalid"];
+export declare const APPLICATION_ERROR_RECOVERY_IDS: readonly ["comment-command-length", "comment-command-name-missing", "comment-command-name-unknown", "comment-command-argument-count", "comment-command-arguments-unexpected", "comment-command-arguments-missing", "comment-command-finding-quoting", "comment-command-review-format", "comment-command-review-effort", "comment-command-review-boolean", "comment-command-review-option", "comment-command-sync-option", "comment-command-sync-parent", "pull-request-link-restored", "pull-request-link-base-retained", "pull-request-link-reference-retained", "pull-request-link-base-and-reference-retained", "managed-branch-enrichment-failed", "inactivity-explanation-failed", "bugbot-review-blocks-pending", "branch-sync-agent-disabled", "branch-sync-fixer-unavailable", "branch-sync-resolution-invalid", "branch-sync-verification-failed", "branch-sync-catalog-incompatible", "branch-sync-workflow-write-required", "branch-sync-publication-failed", "sdd-draft-size-exceeded", "sdd-draft-response-too-short", "sdd-catalog-unsupported-profile", "sdd-catalog-format-invalid", "sdd-catalog-missing-trusted-source", "sdd-source-context-unavailable", "sdd-draft-format-invalid", "sdd-draft-case-identity-invalid", "sdd-draft-case-budget-invalid", "sdd-draft-requirement-mapping-invalid", "sdd-draft-repository-path-invalid", "deployment-publication-context-missing", "workspace-changes-rejected", "closed-issue-reconciliation-failed", "approval-evidence-read-failed", "change-size-reconciliation-failed", "issue-assignment-failed", "issue-assignment-count-invalid", "issue-workflow-admission-blocked", "progress-binary-evidence-unavailable", "progress-inventory-incomplete", "progress-evidence-capacity-exceeded", "bugbot-review-incomplete", "progress-result-contract-invalid", "progress-partition-length-invalid", "progress-assessment-capacity-exceeded", "progress-scope-clause-limit", "progress-completion-recovery-exhausted", "stored-configuration-schema-missing", "stored-configuration-schema-unsupported", "stored-configuration-invalid"];
 export type ApplicationErrorRecoveryId = typeof APPLICATION_ERROR_RECOVERY_IDS[number];
 interface ApplicationErrorRecoveryVariables extends Readonly<Record<CopilotCommandValidationReason, Readonly<{
     command: CopilotCommandName;
@@ -30,8 +42,18 @@ interface ApplicationErrorRecoveryVariables extends Readonly<Record<CopilotComma
     readonly 'closed-issue-reconciliation-failed': ClosedIssueReconciliationFacts;
     readonly 'approval-evidence-read-failed': ApprovalEvidenceDiagnostic;
     readonly 'change-size-reconciliation-failed': ChangeSizeReconciliationFacts;
+    readonly 'issue-assignment-failed': IssueAssignmentDiagnostic;
+    readonly 'issue-assignment-count-invalid': Readonly<Record<string, never>>;
     readonly 'issue-workflow-admission-blocked': IssueWorkflowDiagnosticFacts;
     readonly 'progress-binary-evidence-unavailable': ProgressBinaryEvidenceFacts;
+    readonly 'progress-inventory-incomplete': ProgressInventoryDiagnostic;
+    readonly 'progress-evidence-capacity-exceeded': ProgressCapacityDiagnostic;
+    readonly 'bugbot-review-incomplete': BugbotReviewBlockFacts;
+    readonly 'progress-result-contract-invalid': ProgressResponseDiagnosticFacts;
+    readonly 'progress-partition-length-invalid': ProgressPartitionLengthDiagnostic;
+    readonly 'progress-assessment-capacity-exceeded': ProgressResponseDiagnosticFacts;
+    readonly 'progress-scope-clause-limit': ProgressScopeCapacityFacts;
+    readonly 'progress-completion-recovery-exhausted': ProgressCompletionDiagnostic;
     readonly 'pull-request-link-restored': Readonly<Record<string, never>>;
     readonly 'pull-request-link-base-retained': Readonly<Record<string, never>>;
     readonly 'pull-request-link-reference-retained': Readonly<Record<string, never>>;
@@ -56,9 +78,17 @@ interface ApplicationErrorRecoveryVariables extends Readonly<Record<CopilotComma
         command: '/copilot sync-branch';
     }>;
     readonly 'branch-sync-verification-failed': BranchSyncVerificationFailure;
+    readonly 'branch-sync-catalog-incompatible': BranchSyncCatalogDiagnostic & Readonly<{
+        abort: 'completed' | 'unverified';
+    }>;
+    readonly 'branch-sync-workflow-write-required': BranchSyncPublicationDiagnostic;
+    readonly 'branch-sync-publication-failed': BranchSyncPublicationDiagnostic;
     readonly 'sdd-draft-size-exceeded': Readonly<Record<string, never>>;
+    readonly 'sdd-draft-response-too-short': SddDraftMinimumDiagnostic;
     readonly 'sdd-catalog-unsupported-profile': Readonly<Record<string, never>>;
     readonly 'sdd-catalog-format-invalid': Readonly<Record<string, never>>;
+    readonly 'sdd-catalog-missing-trusted-source': Readonly<Record<string, never>>;
+    readonly 'sdd-source-context-unavailable': SddSourceContextDiagnostic;
     readonly 'sdd-draft-format-invalid': Readonly<Record<string, never>>;
     readonly 'sdd-draft-case-identity-invalid': Readonly<Record<string, never>>;
     readonly 'sdd-draft-case-budget-invalid': Readonly<Record<string, never>>;

package/build/api/src/domain/agent_source_snapshot.d.ts

@@ -0,0 +1,24 @@
+/** SDK-owned source identity; never a user-selected workspace or provider option. */
+export interface AgentSourceSnapshot {
+    readonly kind: 'pre-branch-sdd';
+    readonly phase: 'analysis' | 'draft';
+    readonly baseSha: string;
+}
+export declare const SDD_SOURCE_CONTEXT_REASONS: readonly ["binding-invalid", "git-unavailable", "object-unavailable", "unsafe-entry", "entry-limit", "file-limit", "blob-limit", "byte-limit", "metadata-limit", "materialization-failed", "view-integrity"];
+export type SddSourceContextReason = typeof SDD_SOURCE_CONTEXT_REASONS[number];
+export interface SddSourceContextDiagnostic {
+    readonly sourceCommit: string;
+    readonly phase: AgentSourceSnapshot['phase'] | 'unknown';
+    readonly reason: SddSourceContextReason;
+}
+export declare function isSddSourceContextDiagnostic(value: unknown): value is SddSourceContextDiagnostic;
+/** Also protects renderers called with untyped external records. */
+export declare function sourceContextDiagnostic(value: unknown): SddSourceContextDiagnostic;
+export declare function isSddSourceContextReason(value: unknown): value is SddSourceContextReason;
+export declare function readAgentSourceSnapshot(value: unknown): AgentSourceSnapshot | undefined;
+/** Closed host facts only. Git output, paths, credentials and producer text are discarded. */
+export declare class SddSourceContextFailure extends Error {
+    readonly reason: SddSourceContextReason;
+    readonly source: AgentSourceSnapshot | undefined;
+    constructor(reason: SddSourceContextReason, source?: unknown);
+}

package/build/api/src/domain/branch_sync_catalog_diagnostic.d.ts

@@ -0,0 +1,24 @@
+/** Closed compatibility facts; catalog values never become public operands. */
+export declare const BRANCH_SYNC_CATALOG_MAX_BYTES: number;
+export declare const BRANCH_SYNC_CATALOG_PROFILES: readonly ["sdk-v1", "legacy-evidence", "native", "ambiguous", "unknown"];
+export declare const BRANCH_SYNC_CATALOG_PHASES: readonly ["workspace-boundary", "catalog-file-boundary", "metadata-json", "metadata-conflict-markers", "metadata-shape", "profile-compatibility", "evidence-shape", "evidence-path-boundary", "catalog-contract", "index-output"];
+export declare const SDK_CATALOG_PATH_FIELDS: readonly ["specs", "workflows", "entrypoints", "code", "tests", "documentation"];
+export declare const BRANCH_SYNC_CATALOG_FIELDS: readonly ["catalog", "version", "capabilities", "$schema", "specs", "workflows", "entrypoints", "code", "tests", "documentation", "id", "title", "status", "scope", "owner", "lastVerified", "evidence", "specification"];
+export type BranchSyncCatalogProfile = typeof BRANCH_SYNC_CATALOG_PROFILES[number];
+export type BranchSyncCatalogPhase = typeof BRANCH_SYNC_CATALOG_PHASES[number];
+export type BranchSyncCatalogField = typeof BRANCH_SYNC_CATALOG_FIELDS[number];
+export interface BranchSyncCatalogDiagnostic {
+    readonly phase: BranchSyncCatalogPhase;
+    readonly profile: BranchSyncCatalogProfile;
+    readonly field: BranchSyncCatalogField;
+    /** Zero is document scope; positive positions identify one capability. */
+    readonly capabilityNumber: number;
+}
+export declare function isBranchSyncCatalogDiagnostic(value: unknown): value is BranchSyncCatalogDiagnostic;
+export declare function catalogDiagnostic(phase: BranchSyncCatalogPhase, profile?: BranchSyncCatalogProfile, field?: BranchSyncCatalogField, capabilityNumber?: number): BranchSyncCatalogDiagnostic;
+export declare class BranchSyncCatalogFailure extends Error {
+    readonly diagnostic: BranchSyncCatalogDiagnostic;
+    constructor(diagnostic: BranchSyncCatalogDiagnostic);
+}
+/** Classifies dialect/array shape only; the bundled validator still owns full SDK conformance. */
+export declare function classifyBranchSyncCatalog(value: unknown): BranchSyncCatalogDiagnostic;

package/build/api/src/domain/branch_sync_publication.d.ts

@@ -0,0 +1,18 @@
+export declare const BRANCH_SYNC_PUBLICATION_REASONS: readonly ["workflow-write-required", "push-failed", "candidate-unverified"];
+export declare const BRANCH_SYNC_REMOTE_STATES: readonly ["unchanged", "published", "changed", "unverified"];
+export interface BranchSyncPublicationDiagnostic {
+    readonly reason: typeof BRANCH_SYNC_PUBLICATION_REASONS[number];
+    readonly remoteState: typeof BRANCH_SYNC_REMOTE_STATES[number];
+    readonly originalSha: string;
+    readonly candidateSha: string;
+    readonly observedSha: string;
+    readonly pushAttempted: boolean;
+}
+export declare function isBranchSyncObjectId(value: unknown): value is string;
+export declare function admittedBranchSyncObjectId(value: unknown): string;
+export declare function isBranchSyncPublicationDiagnostic(value: unknown): value is BranchSyncPublicationDiagnostic;
+/** A committed candidate is no longer an in-progress Git merge. */
+export declare class BranchSyncPublicationFailure extends Error {
+    readonly diagnostic: BranchSyncPublicationDiagnostic;
+    constructor(diagnostic: BranchSyncPublicationDiagnostic);
+}

package/build/api/src/domain/bugbot/context.d.ts

@@ -11,7 +11,7 @@ export interface BugbotSourceCoverage {
     /** Exact bounded provider identities of retained conversation items truncated by the prompt. */
     readonly truncatedItemIds?: readonly string[];
     readonly limitReached: boolean;
-    /** True when a provider page cap hides an unknown number of older records. */
+    /** True when the provider page cap prevents fetching additional records. */
     readonly providerLimitReached?: boolean;
 }
 export interface BugbotContextCoverage {
@@ -38,6 +38,12 @@ export interface BugbotReviewTarget {
     };
 }
 export interface BugbotPullRequestIdentity {
+    /** Required by source-bound framed reviews; supplied by canonical provider facts. */
+    readonly baseSha?: string;
+    /** Live target branch tip; PR base.sha may retain an earlier comparison revision. */
+    readonly baseRefSha?: string;
+    readonly baseRef?: string;
+    readonly changedFileCount?: number;
     readonly number: number;
     readonly state: "open" | "closed";
     readonly draft: boolean;

package/build/api/src/domain/bugbot/framed_review.d.ts

@@ -0,0 +1,98 @@
+/** Closed invocation-only review capacity. No caller-supplied limit can expand it. */
+export declare const BUGBOT_FRAMED_LIMITS: Readonly<{
+    files: 1000;
+    fragments: 4096;
+    rawUtf16: 8192000;
+    normalizedUtf16: 8192000;
+    fragmentUtf16: 12000;
+    partitionUtf16: 64000;
+    renderedUtf16: 8192000;
+    partitions: 128;
+    frames: 2;
+    framePartitions: 64;
+    promptBytes: number;
+    promptTotalBytes: number;
+    responseBytes: number;
+    resultBytes: number;
+    findingsPerResponse: 200;
+    findings: 2000;
+    resolutions: 500;
+    recoveredFiles: 64;
+    recoveredPatchBytes: number;
+    recoveredPatchTotalBytes: number;
+    blobBytes: number;
+    blobTotalBytes: number;
+    gitReads: 256;
+}>;
+export type BugbotFramedResource = keyof typeof BUGBOT_FRAMED_LIMITS;
+export type BugbotReviewBlockReason = BugbotFramedResource | 'source' | 'identity' | 'manifest' | 'coverage' | 'receipt' | 'capability';
+export type BugbotReviewCountUnit = 'UTF-16 code units' | 'UTF-8 bytes' | 'items' | 'operations';
+export interface BugbotReviewBlockFacts {
+    readonly profile: 'framed-v1';
+    readonly countKind: 'exact' | 'at-least';
+    readonly resource: BugbotReviewBlockReason;
+    readonly observed: number;
+    readonly limit: number;
+    readonly unit: BugbotReviewCountUnit;
+}
+/** Content-free deterministic failure, mapped to localized semantic errors by the application. */
+export declare class BugbotReviewCompletenessError extends Error {
+    readonly facts: BugbotReviewBlockFacts;
+    constructor(resource: BugbotReviewBlockReason, observed?: number, limit?: number, unit?: BugbotReviewCountUnit, countKind?: 'exact' | 'at-least');
+}
+export declare function enforceBugbotFramedBudget(resource: BugbotFramedResource, observed: number): void;
+export interface BugbotFramedReviewIdentity {
+    readonly owner: string;
+    readonly repository: string;
+    readonly repositoryId?: number;
+    readonly pullRequestNumber: number;
+    readonly baseRef: string;
+    readonly baseSha: string;
+    readonly headOwner: string;
+    readonly headRepository: string;
+    readonly headRef: string;
+    readonly headSha: string;
+    readonly mergeBaseSha: string;
+}
+export interface BugbotReviewGitEntry {
+    readonly mode: '100644' | '100755';
+    readonly oid: string;
+}
+export interface BugbotFramedChange {
+    readonly git?: {
+        readonly old?: BugbotReviewGitEntry;
+        readonly current?: BugbotReviewGitEntry;
+    };
+    readonly filename: string;
+    readonly previousFilename?: string;
+    readonly status: string;
+    readonly additions: number;
+    readonly deletions: number;
+    readonly patch: string;
+    readonly source: 'provider' | 'local-git';
+}
+export interface BugbotFramedReviewSource {
+    readonly identity: BugbotFramedReviewIdentity;
+    readonly changes: readonly BugbotFramedChange[];
+    readonly complete: boolean;
+    /** Content-free measured source work; never a substitute for immutable coverage proof. */
+    readonly metrics?: {
+        readonly gitReads: number;
+        readonly verifiedBlobs: number;
+        readonly verifiedBlobBytes: number;
+        readonly recoveredFiles: number;
+        readonly recoveredPatchBytes: number;
+    };
+}
+/** A receipt binds every fragment in one exact partition to its source and invocation. */
+export interface BugbotFramedAssignment {
+    readonly profile: 'framed-v1';
+    readonly manifestDigest: string;
+    readonly frameId: string;
+    readonly frameOrdinal: number;
+    readonly frameTotal: number;
+    readonly baseSha: string;
+    readonly fragmentIds: readonly string[];
+    readonly coverageDigest: string;
+}
+export declare function isBugbotReviewBlockFacts(value: object): boolean;

package/build/api/src/domain/issue_assignment_diagnostic.d.ts

@@ -0,0 +1,19 @@
+export declare const ASSIGNMENT_STAGES: readonly ["read-assignees", "lookup-members", "select-members", "assign-creator", "assign-members"];
+export declare const ASSIGNMENT_OPERATIONS: readonly ["read-assignees", "list-teams", "list-team-members", "add-assignees", "initialize-client", "unavailable"];
+export type AssignmentStage = typeof ASSIGNMENT_STAGES[number];
+export type AssignmentOperation = typeof ASSIGNMENT_OPERATIONS[number];
+/** Counts describe only this assignment attempt; other lifecycle results remain independent. */
+export interface IssueAssignmentDiagnostic {
+    readonly targetNumber: number;
+    readonly desiredCount: number;
+    readonly stage: AssignmentStage;
+    readonly operation: AssignmentOperation;
+    readonly providerStatus: string;
+    readonly assigneeRead: 'verified' | 'unavailable';
+    readonly observedAssignees: number | 'unavailable';
+    readonly confirmedAssignments: number;
+    readonly remainingAssignments: number | 'unavailable';
+    readonly mutation: 'not-attempted' | 'unverified' | 'verified';
+}
+export declare function isAssignmentProviderStatus(value: unknown): value is string;
+export declare function isIssueAssignmentDiagnostic(value: Readonly<Record<string, unknown>>): boolean;

package/build/api/src/domain/progress_capacity_diagnostic.d.ts

@@ -0,0 +1,136 @@
+export type ProgressCapacityPhase = 'input' | 'source' | 'scope' | 'partition' | 'aggregate' | 'assessment';
+export type ProgressCapacityUnit = 'bytes' | 'parts' | 'lines' | 'code-points' | 'units';
+export type ProgressCapacityBound = 'minimum' | 'maximum' | 'unavailable';
+export type ProgressCapacityCount = number | 'unavailable';
+export declare const PROGRESS_CAPACITY_DIMENSIONS: Readonly<{
+    'source-unit-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'source-part-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'source-part-count': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'source-unit-count': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'source-manifest-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'source-line-count': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'source-line-points': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'input-text-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'native-prompt-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'native-prompt-reserve-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'aggregate-reserve-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'aggregate-allocation-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'aggregate-envelope-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'minimum-fact-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'evidence-unit-count': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'aggregate-fact-bytes': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+    'invalid-allocation': Readonly<{
+        phases: readonly ProgressCapacityPhase[];
+        unit: ProgressCapacityUnit;
+        bounds: readonly ProgressCapacityBound[];
+    }>;
+}>;
+export type ProgressCapacityDimension = keyof typeof PROGRESS_CAPACITY_DIMENSIONS;
+export type ProgressCapacityContext = Readonly<{
+    kind: 'unavailable';
+}> | Readonly<{
+    kind: 'source-line';
+    sourceLineId: string;
+}> | Readonly<{
+    kind: 'comparison';
+    baseSha: string;
+    headSha: string;
+    manifestDigest: string;
+    sourceLineId: string;
+    requiredPathsDigest: string;
+    reviewedPathsDigest: string;
+    uncoveredPathsDigest: string;
+    requiredPathCount: number;
+    reviewedPathCount: number;
+    uncoveredPathCount: number;
+    paths: readonly string[];
+}>;
+export interface ProgressCapacityDiagnostic {
+    readonly phase: ProgressCapacityPhase;
+    readonly dimension: ProgressCapacityDimension;
+    readonly unit: ProgressCapacityUnit;
+    readonly bound: ProgressCapacityBound;
+    readonly observedCount: ProgressCapacityCount;
+    readonly supportedLimit: ProgressCapacityCount;
+    readonly countKind: 'exact' | 'at-least' | 'unavailable';
+    readonly context: ProgressCapacityContext;
+}
+export interface ProgressCapacityInput {
+    readonly phase: ProgressCapacityPhase;
+    readonly dimension: ProgressCapacityDimension;
+    readonly observedCount: ProgressCapacityCount;
+    readonly supportedLimit: ProgressCapacityCount;
+    readonly bound?: ProgressCapacityBound;
+    readonly countKind?: ProgressCapacityDiagnostic['countKind'];
+    readonly context?: ProgressCapacityContext;
+}
+/** Shape validation does not certify a source; host call sites own attribution. */
+export declare function normalizeProgressCapacityContext(value: unknown): ProgressCapacityContext;
+/** Reject incoherent or arbitrary metadata and copy/freeze the complete public value. */
+export declare function normalizeProgressCapacityDiagnostic(value: unknown): ProgressCapacityDiagnostic;
+/** Unit/bound defaults are host policy, never text supplied by a model. */
+export declare function progressCapacityDiagnostic(input: ProgressCapacityInput): ProgressCapacityDiagnostic;

package/build/api/src/domain/progress_completion_diagnostic.d.ts

@@ -0,0 +1,9 @@
+/** Closed facts about a rejected model response, never execution or approval evidence. */
+export type ProgressCompletionDiagnostic = Readonly<{
+    readonly reportedProgress: number;
+    readonly requirementCount: number;
+    readonly supportedCount: number;
+    readonly missingCount: number;
+    readonly unknownCount: number;
+}>;
+export declare function normalizeProgressCompletionDiagnostic(value: unknown): ProgressCompletionDiagnostic;

package/build/api/src/domain/progress_inventory_diagnostic.d.ts

@@ -0,0 +1,13 @@
+export declare const PROGRESS_INVENTORY_REASONS: readonly ["inventory", "identity", "capability", "prefix", "source-moved", "binary", "file-count", "files", "bytes", "requests", "treeEntries", "frames", "blob-size", "units", "partition", "manifest", "facts"];
+export type ProgressInventoryReason = typeof PROGRESS_INVENTORY_REASONS[number];
+export interface ProgressInventoryDiagnostic {
+    readonly profile: 'immutable-tree-v1';
+    readonly reason: ProgressInventoryReason;
+    readonly observedCount: number;
+    readonly supportedLimit: number;
+    readonly countKind: 'exact' | 'at-least';
+    readonly paths: string;
+}
+export declare function progressInventoryDiagnostic(reason: ProgressInventoryReason, observedCount: number, supportedLimit: number, paths: readonly string[], countKind?: 'exact' | 'at-least'): ProgressInventoryDiagnostic;
+export declare function isProgressInventoryDiagnostic(value: object): boolean;
+export declare function progressInventoryPresentation(facts: ProgressInventoryDiagnostic): Readonly<Record<string, string | number>>;

package/build/api/src/domain/progress_partition_length_failure.d.ts

@@ -0,0 +1,20 @@
+import { ProgressResponseContractFailure, type ProgressResponseDiagnosticFacts } from './progress_response_diagnostic';
+export type ProgressPartitionLengthDiagnostic = Readonly<{
+    readonly partitionId: string;
+    readonly filePath: string;
+    readonly unitId: string;
+    readonly field: string;
+    readonly maximum: number;
+    readonly observed: number;
+}>;
+export type ProgressPartitionLengthContext = ProgressPartitionLengthDiagnostic & Readonly<{
+    readonly outputLocale: string;
+}>;
+/** Completed output supplied these bounded scalars; application must still bind the identity. */
+export declare class ProgressPartitionLengthFailure extends ProgressResponseContractFailure {
+    readonly details: ProgressPartitionLengthContext;
+    constructor(facts: ProgressResponseDiagnosticFacts, details: ProgressPartitionLengthContext);
+}
+/** Closed operator facts; string counts are code points, never raw prose or body bytes. */
+export declare function isProgressPartitionLengthDiagnostic(value: unknown): value is ProgressPartitionLengthDiagnostic;
+export declare function progressPartitionLengthPresentation(facts: ProgressPartitionLengthDiagnostic): Readonly<Record<string, string | number>>;

package/build/api/src/domain/progress_response_diagnostic.d.ts

@@ -0,0 +1,34 @@
+export declare const PROGRESS_RESPONSE_PHASES: readonly ["scope", "partition", "assessment"];
+export type ProgressResponsePhase = typeof PROGRESS_RESPONSE_PHASES[number];
+export declare const PROGRESS_RESPONSE_REASONS: Readonly<{
+    scope: readonly ["json-invalid", "schema-type", "schema-enum", "schema-string-short", "schema-string-long", "schema-number-finite", "schema-number-min", "schema-number-max", "schema-array-short", "schema-array-long", "schema-required", "schema-additional", "response-not-object", "output-locale-missing", "output-locale-invalid", "output-locale-mismatch", "response-shape-invalid", "scope-incomplete", "scope-entry-invalid", "scope-source-id-invalid", "scope-source-id-duplicate", "scope-classification-invalid", "scope-clause-limit", "scope-no-requirements", "scope-budget"];
+    partition: readonly ["json-invalid", "schema-type", "schema-enum", "schema-string-short", "schema-string-long", "schema-number-finite", "schema-number-min", "schema-number-max", "schema-array-short", "schema-array-long", "schema-required", "schema-additional", "response-not-object", "output-locale-missing", "output-locale-invalid", "output-locale-mismatch", "response-shape-invalid", "partition-shape-invalid", "partition-id-invalid", "partition-files-incomplete", "partition-file-invalid", "partition-unit-invalid", "partition-facts-invalid"];
+    assessment: readonly ["json-invalid", "schema-type", "schema-enum", "schema-string-short", "schema-string-long", "schema-number-finite", "schema-number-min", "schema-number-max", "schema-array-short", "schema-array-long", "schema-required", "schema-additional", "response-not-object", "output-locale-missing", "output-locale-invalid", "output-locale-mismatch", "response-shape-invalid", "requirements-incomplete", "progress-invalid", "requirement-shape-invalid", "requirement-id-invalid", "requirement-id-duplicate", "scope-uncertain", "requirement-status-invalid", "requirement-evidence-invalid", "requirement-summary-invalid", "requirement-remaining-invalid", "requirement-evidence-mismatch", "progress-completion-mismatch", "assessment-text-limit"];
+}>;
+export type ProgressResponseReason = typeof PROGRESS_RESPONSE_REASONS[ProgressResponsePhase][number];
+export type ProgressResponseDiagnosticFacts = Readonly<{
+    phase: ProgressResponsePhase;
+    reason: ProgressResponseReason;
+    field: string;
+    requirementId: string;
+    sourceLineId: string;
+}>;
+export declare const isProgressRequirementId: (value: unknown) => value is string;
+export declare const isProgressSourceLineId: (value: unknown) => value is string;
+export declare function isProgressResponseField(phase: ProgressResponsePhase, value: unknown): value is string;
+/** Unknown model keys and oversized locations never become operator field names. */
+export declare function safeProgressResponseField(phase: ProgressResponsePhase, value: unknown): string;
+export declare function isProgressResponseDiagnosticFacts(value: unknown): value is ProgressResponseDiagnosticFacts;
+/** Carries bounded completed-output facts, never a raw output or exception cause. */
+export declare class ProgressResponseContractFailure extends Error {
+    readonly facts: ProgressResponseDiagnosticFacts;
+    constructor(facts: ProgressResponseDiagnosticFacts);
+}
+/** Exact counts after complete host-validated source classification; never raw model prose. */
+export type ProgressScopeCapacityFacts = Readonly<{
+    clauseKind: 'required-or-uncertain' | 'excluded';
+    observed: number;
+    limit: 32;
+    sourceLineId: string;
+}>;
+export declare function isProgressScopeCapacityFacts(value: unknown): value is ProgressScopeCapacityFacts;

package/build/api/src/domain/sdd_validation_diagnostic.d.ts

@@ -0,0 +1,26 @@
+/** Public diagnostics contain only closed checks and bounded ordinal/count facts. */
+export declare const SDD_DRAFT_FORMAT_REASONS: readonly ["required-heading", "test-budget", "case-identity", "case-budget", "requirement-mapping", "repository-path"];
+export type SddDraftFormatReason = typeof SDD_DRAFT_FORMAT_REASONS[number];
+export declare const SDD_VALIDATION_DETAILS: readonly ["validation-contract", "size-limit", "response-shape", "minimum-length", "required-heading", "numeric-budget", "section-count", "table-count", "table-separator", "table-columns", "table-empty-cell", "table-empty", "derived-slot-count", "derived-slot-placement", "identifier-list", "requirement-identity", "requirement-reserved", "case-identity", "case-reserved", "case-reference", "case-shorthand", "budget-area", "budget-integer", "budget-order", "budget-total", "budget-distribution", "requirement-reference", "requirement-coverage", "traceability-links", "traceability-membership", "traceability-requirement", "owner-path", "path-identity", "create-existing-path", "create-path-overlap", "create-path-parent", "path-operation", "path-reference", "path-link", "path-inline-reference", "path-prose-reference", "path-link-reference", "path-reference-unsafe", "path-reference-blocked", "path-reference-missing", "path-reference-directory"];
+export type SddValidationDetail = typeof SDD_VALIDATION_DETAILS[number];
+export interface SddValidationFact {
+    readonly detail: SddValidationDetail;
+    readonly section: 0 | 4 | 14 | 15 | 17;
+    readonly row?: number;
+    readonly expected?: number;
+    readonly observed?: number;
+}
+export interface SddValidationDiagnostic {
+    readonly reason: SddDraftFormatReason | 'size' | 'response-shape' | 'response-minimum';
+    readonly phase: 'response' | 'assembly' | 'validation';
+    readonly facts: readonly SddValidationFact[];
+}
+export interface SddDraftMinimumDiagnostic {
+    readonly minimum: number;
+    readonly observed: number | 'unavailable';
+    readonly attempts: 1 | 2;
+}
+/** Counts authorize no publication and never carry the rejected response. */
+export declare function isSddDraftMinimumDiagnostic(input: unknown): input is SddDraftMinimumDiagnostic;
+/** Fail closed on extra fields, arbitrary text, unbounded facts or invalid coordinates. */
+export declare function normalizeSddValidationDiagnostic(input: SddValidationDiagnostic): SddValidationDiagnostic;