@wrongstack/governance 0.298.0

package/dist/project-server.d.ts

@@ -0,0 +1,48 @@
+import type { GovernanceAttachmentBrokerLifecycleEvent } from './attachment-broker-controller.js';
+import { type GovernanceCapabilityGrantRegistryOptions, type IssuedGovernanceCapabilityGrant, type IssueGovernanceCapabilityGrantOptions } from './capability-grant.js';
+import type { GovernanceDaemonControlPort, GovernanceDaemonShutdownNotice } from './daemon-control.js';
+import { type GovernanceDecisionContextProvider } from './project-service.js';
+export declare const GOVERNANCE_IPC_MAX_CONNECTIONS = 128;
+export declare const GOVERNANCE_IPC_SOCKET_TIMEOUT_MS = 10000;
+export interface GovernanceProjectServerOptions {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly resolveDecisionContext?: GovernanceDecisionContextProvider | undefined;
+    readonly grantRegistry?: Omit<GovernanceCapabilityGrantRegistryOptions, 'auditSink'> | undefined;
+    readonly daemonControl?: GovernanceDaemonControlPort | undefined;
+    readonly onDaemonShutdownResponseFlushed?: ((notice: GovernanceDaemonShutdownNotice) => void) | undefined;
+}
+export declare class GovernanceProjectServer {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly endpoint: string;
+    readonly databasePath: string;
+    private readonly options;
+    private readonly sockets;
+    private readonly pendingSockets;
+    private state;
+    private listener;
+    private store;
+    private authenticated;
+    private grants;
+    private lastListenerError;
+    constructor(options: GovernanceProjectServerOptions);
+    get storageOpen(): boolean;
+    get ready(): boolean;
+    get listenerError(): Error | null;
+    start(): Promise<void>;
+    issueGrant(options: IssueGovernanceCapabilityGrantOptions): IssuedGovernanceCapabilityGrant;
+    revokeGrant(grantId: string, reason?: string): boolean;
+    recordAttachmentBrokerEvent(event: GovernanceAttachmentBrokerLifecycleEvent): void;
+    close(): Promise<void>;
+    private ensureEndpointParent;
+    private listen;
+    private onConnection;
+    private accept;
+    private handleLine;
+    private send;
+    private persistGrantAuditEvent;
+    private persistDaemonShutdownAudit;
+    private closeListener;
+}
+//# sourceMappingURL=project-server.d.ts.map

package/dist/project-service.d.ts

@@ -0,0 +1,121 @@
+import type { GovernanceAttachmentBrokerControllerSnapshot } from './attachment-broker-controller.js';
+import type { GovernanceCapabilityGrant, GovernanceServiceCredential } from './capability-grant.js';
+import type { AppendGovernanceObservationResult, GovernanceCommandExecution, GovernanceCommandReceipt, GovernanceEventStore, StoredGovernanceObservation } from './event-store.js';
+import { type GovernanceEvidenceCandidateLedgerEntry } from './evidence-candidate.js';
+import { GOVERNANCE_SERVICE_PROTOCOL_VERSION, type GovernanceServiceClientContext, type GovernanceServiceRequest } from './service-protocol.js';
+import type { GovernanceCommand, GovernanceDecisionContext, GovernanceEvent, TaskAggregate } from './task-aggregate.js';
+import type { RecordWorkspaceSnapshotResult } from './workspace-snapshot-fence.js';
+export type { GovernanceServiceCapability, GovernanceServiceClientContext, GovernanceServiceRequest, } from './service-protocol.js';
+export { GOVERNANCE_SERVICE_CAPABILITIES, GOVERNANCE_SERVICE_PROTOCOL_VERSION, } from './service-protocol.js';
+export type GovernanceServiceResult = {
+    readonly type: 'health';
+    readonly projectId: string;
+    readonly protocolVersion: typeof GOVERNANCE_SERVICE_PROTOCOL_VERSION;
+    readonly status: 'ready';
+} | {
+    readonly type: 'task';
+    readonly task: TaskAggregate | null;
+} | {
+    readonly type: 'events';
+    readonly events: readonly GovernanceEvent[];
+} | {
+    readonly type: 'receipt';
+    readonly receipt: GovernanceCommandReceipt | null;
+} | {
+    readonly type: 'observations';
+    readonly observations: readonly StoredGovernanceObservation[];
+} | {
+    readonly type: 'evidence_candidates';
+    readonly taskId: string;
+    readonly candidates: readonly GovernanceEvidenceCandidateLedgerEntry[];
+    readonly nextAfterSequence: number | null;
+} | {
+    readonly type: 'command_result';
+    readonly execution: GovernanceCommandExecution;
+} | {
+    readonly type: 'observation_result';
+    readonly result: AppendGovernanceObservationResult;
+} | {
+    readonly type: 'workspace_snapshot_recorded';
+    readonly result: RecordWorkspaceSnapshotResult;
+} | {
+    readonly type: 'capability_grant_issued';
+    readonly grant: GovernanceCapabilityGrant;
+    readonly credential: GovernanceServiceCredential;
+} | {
+    readonly type: 'runtime_attachment_claimed';
+    readonly control: {
+        readonly grant: GovernanceCapabilityGrant;
+        readonly credential: GovernanceServiceCredential;
+    };
+    readonly model: {
+        readonly grant: GovernanceCapabilityGrant;
+        readonly credential: GovernanceServiceCredential;
+    };
+} | {
+    readonly type: 'runtime_attachment_released';
+    readonly controlGrantId: string;
+    readonly modelGrantId: string;
+} | {
+    readonly type: 'own_capability_grant';
+    readonly grant: GovernanceCapabilityGrant;
+} | {
+    readonly type: 'daemon_status';
+    readonly projectId: string;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly startedAt: string;
+    readonly attachmentBroker?: GovernanceAttachmentBrokerControllerSnapshot | undefined;
+} | {
+    readonly type: 'daemon_shutdown_accepted';
+    readonly instanceId: string;
+    readonly requestedBy: string;
+    readonly reason: string;
+} | {
+    readonly type: 'capability_grants';
+    readonly grants: readonly GovernanceCapabilityGrant[];
+    readonly nextCursor?: string | undefined;
+} | {
+    readonly type: 'capability_grant_revoked';
+    readonly grantId: string;
+    readonly revoked: boolean;
+} | {
+    readonly type: 'capability_grant_rotated';
+    readonly previousGrantId: string;
+    readonly grant: GovernanceCapabilityGrant;
+    readonly credential: GovernanceServiceCredential;
+};
+export type GovernanceServiceErrorCode = 'unsupported_protocol' | 'invalid_request' | 'authentication_failed' | 'permission_denied' | 'identity_mismatch' | 'project_mismatch' | 'store_failure' | 'request_in_progress';
+export type GovernanceServiceResponse = {
+    readonly ok: true;
+    readonly requestId: string;
+    readonly result: GovernanceServiceResult;
+} | {
+    readonly ok: false;
+    readonly requestId: string;
+    readonly error: {
+        readonly code: GovernanceServiceErrorCode;
+        readonly message: string;
+        readonly details?: readonly {
+            readonly code: string;
+            readonly path: string;
+            readonly message: string;
+        }[] | undefined;
+    };
+};
+export type GovernanceDecisionContextProvider = (command: GovernanceCommand) => GovernanceDecisionContext;
+export declare class GovernanceProjectService {
+    readonly projectId: string;
+    private readonly store;
+    /** Trusted policy adapter owned by the future daemon, never selected by request payloads. */
+    private readonly resolveDecisionContext;
+    constructor(projectId: string, store: GovernanceEventStore, 
+    /** Trusted policy adapter owned by the future daemon, never selected by request payloads. */
+    resolveDecisionContext?: GovernanceDecisionContextProvider);
+    handleUnknown(input: unknown, client: GovernanceServiceClientContext): GovernanceServiceResponse;
+    handle(request: GovernanceServiceRequest, client: GovernanceServiceClientContext): GovernanceServiceResponse;
+    close(): void;
+    private handleAuthorized;
+    private commandBelongsToProject;
+}
+//# sourceMappingURL=project-service.d.ts.map

package/dist/protocol-decoder.d.ts

@@ -0,0 +1,16 @@
+import { type GovernanceServiceRequest } from './service-protocol.js';
+export type GovernanceProtocolDecodeIssueCode = 'expected_object' | 'expected_array' | 'unknown_field' | 'invalid_value' | 'semantic_invalid' | 'resource_limit';
+export interface GovernanceProtocolDecodeIssue {
+    readonly code: GovernanceProtocolDecodeIssueCode;
+    readonly path: string;
+    readonly message: string;
+}
+export type GovernanceServiceRequestDecodeResult = {
+    readonly decoded: true;
+    readonly request: GovernanceServiceRequest;
+} | {
+    readonly decoded: false;
+    readonly issues: readonly GovernanceProtocolDecodeIssue[];
+};
+export declare function decodeGovernanceServiceRequest(input: unknown): GovernanceServiceRequestDecodeResult;
+//# sourceMappingURL=protocol-decoder.d.ts.map

package/dist/runtime-compatibility.d.ts

@@ -0,0 +1,99 @@
+import { type ConnectGovernanceAdminSessionOptions, type ConnectGovernanceAdminSessionResult, type GovernanceAdminSession, type GovernanceAdminSessionLeaseOptions, type GovernanceAdminSessionSnapshot } from './admin-session.js';
+import { type GovernanceCapabilityGrant, type GovernanceServiceCredential } from './capability-grant.js';
+import { type GovernanceProjectDaemonLaunch, launchGovernanceProjectDaemon } from './daemon-launcher.js';
+import { type GovernanceDaemonMetadata, inspectGovernanceDaemon, readGovernanceDaemonAttachmentBroker } from './daemon-metadata.js';
+import { connectGovernanceProjectClient, GovernanceProjectClient } from './project-client.js';
+import type { GovernanceServiceResponse } from './project-service.js';
+import { type GovernanceRuntimeModelCapability } from './service-protocol.js';
+export declare const GOVERNANCE_COMPATIBILITY_ADMIN_TTL_MS: number;
+export declare const GOVERNANCE_COMPATIBILITY_MODEL_TTL_MS: number;
+export type GovernanceModelCapability = GovernanceRuntimeModelCapability;
+export interface ExistingGovernanceAdminCredential {
+    readonly grantId: string;
+    readonly credential: GovernanceServiceCredential;
+}
+export interface PrepareGovernanceCompatibilityOptions {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly adminClientId: string;
+    readonly modelClientId: string;
+    readonly modelCapabilities: readonly GovernanceModelCapability[];
+    readonly adminTtlMs?: number | undefined;
+    readonly modelTtlMs?: number | undefined;
+    readonly timeoutMs?: number | undefined;
+    readonly existingAdmin?: ExistingGovernanceAdminCredential | undefined;
+    readonly adminLease?: GovernanceAdminSessionLeaseOptions | undefined;
+}
+export type GovernanceCompatibilityFallbackCode = 'invalid_options' | 'inspection_failed' | 'existing_owner_requires_credential' | 'unsafe_daemon_state' | 'attachment_rejected' | 'launch_failed' | 'admin_session_rejected' | 'model_grant_rejected' | 'model_connection_rejected';
+export type GovernanceCompatibilityCleanup = 'not_required' | 'admin_session_stopped' | 'attachment_grants_released' | 'launched_daemon_shutdown_requested' | 'cleanup_failed' | 'unavailable';
+export interface GovernanceCompatibilityFallback {
+    readonly mode: 'legacy';
+    readonly code: GovernanceCompatibilityFallbackCode;
+    readonly phase: 'validate' | 'inspect' | 'attach' | 'launch' | 'provision';
+    readonly message: string;
+    readonly cleanup: GovernanceCompatibilityCleanup;
+}
+export interface GovernanceModelSessionSnapshot {
+    readonly projectId: string;
+    readonly clientId: string;
+    readonly grantId: string;
+    readonly capabilities: readonly GovernanceModelCapability[];
+    readonly expiresAt: string;
+}
+declare const GOVERNANCE_MODEL_SESSION_CONSTRUCTION: unique symbol;
+export declare class GovernanceModelSession {
+    #private;
+    constructor(construction: typeof GOVERNANCE_MODEL_SESSION_CONSTRUCTION, client: GovernanceProjectClient, grant: GovernanceCapabilityGrant);
+    request(input: unknown): Promise<GovernanceServiceResponse>;
+    snapshot(): GovernanceModelSessionSnapshot;
+}
+export interface GovernanceCompatibilityRuntimeSnapshot {
+    readonly source: 'attached' | 'launched';
+    readonly closed: boolean;
+    readonly daemon: GovernanceAdminSessionSnapshot['daemon'];
+    readonly control: {
+        readonly kind: 'admin' | 'attachment';
+        readonly clientId: string;
+        readonly grantId: string;
+        readonly expiresAt: string;
+    };
+    readonly admin: GovernanceAdminSessionSnapshot | null;
+    readonly model: GovernanceModelSessionSnapshot;
+}
+type GovernanceCompatibilityControl = {
+    readonly kind: 'admin';
+    readonly session: GovernanceAdminSession;
+} | {
+    readonly kind: 'attachment';
+    readonly client: GovernanceProjectClient;
+    readonly metadata: GovernanceDaemonMetadata;
+    readonly grant: GovernanceCapabilityGrant;
+};
+declare const GOVERNANCE_COMPATIBILITY_RUNTIME_CONSTRUCTION: unique symbol;
+export declare class GovernanceCompatibilityRuntime {
+    #private;
+    readonly model: GovernanceModelSession;
+    constructor(construction: typeof GOVERNANCE_COMPATIBILITY_RUNTIME_CONSTRUCTION, source: 'attached' | 'launched', control: GovernanceCompatibilityControl, model: GovernanceModelSession);
+    snapshot(): GovernanceCompatibilityRuntimeSnapshot;
+    close(): Promise<GovernanceServiceResponse | null>;
+    shutdownDaemon(reason?: string): Promise<GovernanceServiceResponse>;
+    recordWorkspaceSnapshot(manifestHash: string): Promise<GovernanceServiceResponse>;
+    private revokeModelGrant;
+}
+export type PrepareGovernanceCompatibilityResult = {
+    readonly mode: 'governed';
+    readonly runtime: GovernanceCompatibilityRuntime;
+} | GovernanceCompatibilityFallback;
+interface GovernanceCompatibilityAdapters {
+    readonly inspect: typeof inspectGovernanceDaemon;
+    readonly launch: typeof launchGovernanceProjectDaemon;
+    readonly connectAttached: (options: ConnectGovernanceAdminSessionOptions) => Promise<ConnectGovernanceAdminSessionResult>;
+    readonly connectLaunched: (launch: GovernanceProjectDaemonLaunch, options?: GovernanceAdminSessionLeaseOptions) => Promise<ConnectGovernanceAdminSessionResult>;
+    readonly connectModel: typeof connectGovernanceProjectClient;
+    readonly readAttachmentBroker: typeof readGovernanceDaemonAttachmentBroker;
+}
+export declare function prepareGovernanceCompatibilityRuntime(options: PrepareGovernanceCompatibilityOptions): Promise<PrepareGovernanceCompatibilityResult>;
+/** Internal source-test seam. Package consumers use prepareGovernanceCompatibilityRuntime. */
+export declare function prepareGovernanceCompatibilityRuntimeWithAdapters(options: PrepareGovernanceCompatibilityOptions, adapters: GovernanceCompatibilityAdapters): Promise<PrepareGovernanceCompatibilityResult>;
+export {};
+//# sourceMappingURL=runtime-compatibility.d.ts.map

package/dist/sanitize.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Redact governance credentials (`wsg_`-prefixed tokens) from a message and
+ * cap its length. Single source of truth for the whole workspace — imported by
+ * the governance runtime-compatibility and credential-lease paths, and
+ * re-exported by `@wrongstack/runtime/governance-sanitize` for the CLI's
+ * legacy-fallback path. Lives in `@wrongstack/governance` (a dependency-free
+ * leaf package) so both governance and runtime can use it without an import
+ * cycle (runtime depends on governance, never the reverse).
+ */
+export declare function sanitizeGovernanceMessage(message: string): string;
+//# sourceMappingURL=sanitize.d.ts.map

package/dist/service-protocol.d.ts

@@ -0,0 +1,82 @@
+import type { GovernanceObservation } from './event-store.js';
+import type { GovernanceCommand } from './task-aggregate.js';
+export declare const GOVERNANCE_SERVICE_PROTOCOL_VERSION: 1;
+export declare const GOVERNANCE_SERVICE_CAPABILITIES: readonly ['task_read', 'audit_read', 'command_submit', 'shadow_observe', 'workspace_snapshot_record', 'runtime_attach', 'runtime_attachment_release', 'daemon_status_read', 'capability_admin', 'daemon_control'];
+export type GovernanceServiceCapability = (typeof GOVERNANCE_SERVICE_CAPABILITIES)[number];
+export declare const GOVERNANCE_RUNTIME_MODEL_CAPABILITIES: readonly ["task_read", "audit_read", "command_submit", "shadow_observe"];
+export type GovernanceRuntimeModelCapability = (typeof GOVERNANCE_RUNTIME_MODEL_CAPABILITIES)[number];
+export interface GovernanceServiceClientContext {
+    readonly clientId: string;
+    /** Assigned by the transport/policy layer, never accepted from request payloads. */
+    readonly capabilities: ReadonlySet<GovernanceServiceCapability>;
+}
+export interface GovernanceServiceRequestMetadata {
+    readonly protocolVersion: typeof GOVERNANCE_SERVICE_PROTOCOL_VERSION;
+    readonly requestId: string;
+}
+export type GovernanceServiceRequest = GovernanceServiceRequestMetadata & ({
+    readonly type: 'health';
+} | {
+    readonly type: 'read_task';
+    readonly taskId: string;
+} | {
+    readonly type: 'read_events';
+    readonly taskId: string;
+} | {
+    readonly type: 'read_receipt';
+    readonly commandId: string;
+} | {
+    readonly type: 'read_observations';
+    readonly taskId?: string | undefined;
+} | {
+    readonly type: 'read_evidence_candidates';
+    readonly taskId: string;
+    readonly afterSequence?: number | undefined;
+    readonly limit?: number | undefined;
+} | {
+    readonly type: 'read_audit_observations';
+} | {
+    readonly type: 'read_own_capability_grant';
+} | {
+    readonly type: 'read_daemon_status';
+} | {
+    readonly type: 'request_daemon_shutdown';
+    readonly expectedInstanceId: string;
+    readonly reason?: string | undefined;
+} | {
+    readonly type: 'submit_command';
+    readonly command: GovernanceCommand;
+} | {
+    readonly type: 'record_observation';
+    readonly observation: GovernanceObservation;
+} | {
+    readonly type: 'record_workspace_snapshot';
+    readonly manifestHash: string;
+} | {
+    readonly type: 'issue_capability_grant';
+    readonly clientId: string;
+    readonly capabilities: readonly GovernanceServiceCapability[];
+    readonly ttlMs: number;
+} | {
+    readonly type: 'claim_runtime_attachment';
+    readonly controlClientId: string;
+    readonly modelClientId: string;
+    readonly modelCapabilities: readonly GovernanceRuntimeModelCapability[];
+    readonly ttlMs: number;
+} | {
+    readonly type: 'release_runtime_attachment';
+} | {
+    readonly type: 'list_capability_grants';
+    readonly cursor?: string | undefined;
+    readonly limit?: number | undefined;
+} | {
+    readonly type: 'revoke_capability_grant';
+    readonly grantId: string;
+    readonly reason?: string | undefined;
+} | {
+    readonly type: 'rotate_capability_grant';
+    readonly grantId: string;
+    readonly ttlMs: number;
+    readonly reason?: string | undefined;
+});
+//# sourceMappingURL=service-protocol.d.ts.map

package/dist/task-aggregate.d.ts

@@ -0,0 +1,92 @@
+import { type PlanVersionV1 } from './plan-version.js';
+import { type TaskContractV1 } from './task-contract.js';
+import { type GovernanceActor, type TransitionFacts } from './transition-engine.js';
+import type { WorkflowState } from './workflow-state.js';
+export interface GovernanceCommandMetadata {
+    readonly commandId: string;
+    readonly taskId: string;
+    readonly expectedRevision: number;
+    readonly actor: GovernanceActor;
+    readonly issuedAt: string;
+}
+export type GovernanceCommand = GovernanceCommandMetadata & ({
+    readonly type: 'create_task';
+    readonly projectId: string;
+    readonly contract: TaskContractV1;
+} | {
+    readonly type: 'attach_plan_version';
+    readonly plan: PlanVersionV1;
+} | {
+    readonly type: 'transition_task';
+    readonly to: WorkflowState;
+});
+export interface GovernanceDecisionContext {
+    /** Trusted facts computed by deterministic policy/adapters, never copied from model arguments. */
+    readonly transitionFacts?: TransitionFacts | undefined;
+}
+export type GovernanceEventPayload = {
+    readonly type: 'task_created';
+    readonly projectId: string;
+    readonly contract: TaskContractV1;
+} | {
+    readonly type: 'plan_version_attached';
+    readonly plan: PlanVersionV1;
+} | {
+    readonly type: 'workflow_transitioned';
+    readonly from: WorkflowState;
+    readonly to: WorkflowState;
+};
+export interface GovernanceEvent {
+    readonly eventId: string;
+    readonly commandId: string;
+    readonly taskId: string;
+    readonly revision: number;
+    readonly actor: GovernanceActor;
+    readonly occurredAt: string;
+    readonly payload: GovernanceEventPayload;
+}
+export interface TaskAggregate {
+    readonly taskId: string;
+    readonly projectId: string;
+    readonly revision: number;
+    readonly state: WorkflowState;
+    readonly contracts: readonly TaskContractV1[];
+    readonly activeContractVersion: number;
+    readonly plans: readonly PlanVersionV1[];
+    readonly activePlanVersion: number | null;
+    readonly replanRequestedFromPlanVersion: number | null;
+    readonly createdAt: string;
+    readonly updatedAt: string;
+}
+export type CommandRejectionCode = 'stale_revision' | 'task_already_exists' | 'task_missing' | 'task_identity_mismatch' | 'project_identity_mismatch' | 'initial_contract_version_invalid' | 'contract_invalid' | 'plan_invalid' | 'plan_supersession_invalid' | 'plan_attach_state_invalid' | 'active_plan_missing' | 'replan_version_missing' | 'transition_facts_missing' | 'transition_rejected';
+export type GovernanceCommandDecision = {
+    readonly accepted: true;
+    readonly event: GovernanceEvent;
+} | {
+    readonly accepted: false;
+    readonly code: CommandRejectionCode;
+    readonly message: string;
+    readonly details?: readonly unknown[] | undefined;
+};
+export type EventApplyRejectionCode = 'first_event_not_task_created' | 'duplicate_task_created' | 'task_id_mismatch' | 'event_revision_gap' | 'event_state_mismatch' | 'event_requires_existing_task';
+export type EventApplyResult = {
+    readonly applied: true;
+    readonly aggregate: TaskAggregate;
+} | {
+    readonly applied: false;
+    readonly code: EventApplyRejectionCode;
+    readonly message: string;
+};
+export type TaskReplayResult = {
+    readonly replayed: true;
+    readonly aggregate: TaskAggregate;
+} | {
+    readonly replayed: false;
+    readonly eventIndex: number;
+    readonly code: EventApplyRejectionCode;
+    readonly message: string;
+};
+export declare function decideGovernanceCommand(aggregate: TaskAggregate | null, command: GovernanceCommand, context?: GovernanceDecisionContext): GovernanceCommandDecision;
+export declare function applyGovernanceEvent(aggregate: TaskAggregate | null, event: GovernanceEvent): EventApplyResult;
+export declare function replayTaskEvents(events: readonly GovernanceEvent[]): TaskReplayResult;
+//# sourceMappingURL=task-aggregate.d.ts.map

package/dist/task-contract.d.ts

@@ -0,0 +1,74 @@
+import { type AutonomyEnvelope } from './autonomy-envelope.js';
+export declare const TASK_CONTRACT_SCHEMA_VERSION: 1;
+export declare const CONTRACT_SOURCES: readonly ['explicit_user', 'project_policy', 'deterministic_inference', 'model_proposal'];
+export type ContractSource = (typeof CONTRACT_SOURCES)[number];
+export declare const EVIDENCE_KINDS: readonly ['test', 'typecheck', 'lint', 'build', 'static_analysis', 'security', 'api_compatibility', 'schema', 'performance', 'review'];
+export type EvidenceKind = (typeof EVIDENCE_KINDS)[number];
+export declare const REVIEW_DIMENSIONS: readonly ['correctness', 'requirements_traceability', 'security_permissions', 'api_schema_compatibility', 'testing_evidence', 'performance_resources', 'concurrency_recovery', 'maintainability_architecture'];
+export type ReviewDimension = (typeof REVIEW_DIMENSIONS)[number];
+export declare const ROLLBACK_CLASSES: readonly ['isolated_discard', 'git_revert', 'verified_compensation', 'manual_only', 'irreversible'];
+export type RollbackClass = (typeof ROLLBACK_CLASSES)[number];
+export declare const CONTRACT_ASSUMPTION_STATUSES: readonly ['unverified', 'verified', 'rejected', 'expired'];
+export declare const BASELINE_POLICIES: readonly ['required', 'optional', 'read_only'];
+export interface TaskRequirement {
+    readonly id: string;
+    readonly text: string;
+    readonly acceptanceCriteriaIds: readonly string[];
+}
+export interface AcceptanceCriterion {
+    readonly id: string;
+    readonly statement: string;
+    readonly evidenceKinds: readonly EvidenceKind[];
+}
+export interface RequiredCheck {
+    readonly id: string;
+    readonly kind: EvidenceKind;
+    readonly required: boolean;
+    readonly requirementIds: readonly string[];
+}
+export interface ContractAssumption {
+    readonly id: string;
+    readonly statement: string;
+    readonly source: ContractSource;
+    readonly status: (typeof CONTRACT_ASSUMPTION_STATUSES)[number];
+}
+export interface TaskContractV1 {
+    readonly schemaVersion: typeof TASK_CONTRACT_SCHEMA_VERSION;
+    readonly taskId: string;
+    readonly contractVersion: number;
+    readonly projectId: string;
+    readonly sourceRequest: string;
+    readonly policyVersion: string;
+    readonly repository: {
+        readonly rootIdentity: string;
+        readonly baselinePolicy: (typeof BASELINE_POLICIES)[number];
+    };
+    readonly requirements: readonly TaskRequirement[];
+    readonly acceptanceCriteria: readonly AcceptanceCriterion[];
+    readonly autonomy: AutonomyEnvelope;
+    readonly requiredChecks: readonly RequiredCheck[];
+    readonly requiredReviewDimensions: readonly ReviewDimension[];
+    readonly rollbackClass: RollbackClass;
+    readonly assumptions: readonly ContractAssumption[];
+    readonly sources: {
+        readonly requirements: ContractSource;
+        readonly scope: ContractSource;
+        readonly checks: ContractSource;
+        readonly autonomy: ContractSource;
+    };
+}
+export type ContractValidationIssueCode = 'invalid_schema_version' | 'invalid_contract_version' | 'required_value_missing' | 'duplicate_id' | 'unknown_acceptance_criterion' | 'unknown_requirement' | 'path_scope_missing' | 'path_scope_conflict' | 'invalid_budget' | 'auto_replan_exceeds_budget' | 'approval_operation_not_allowed' | 'operation_exceeds_tier';
+export interface ContractValidationIssue {
+    readonly code: ContractValidationIssueCode;
+    readonly path: string;
+    readonly message: string;
+}
+export type ContractValidationResult = {
+    readonly valid: true;
+} | {
+    readonly valid: false;
+    readonly issues: readonly ContractValidationIssue[];
+};
+export declare function validateTaskContractV1(contract: TaskContractV1): ContractValidationResult;
+export declare function freezeTaskContractV1(contract: TaskContractV1): TaskContractV1;
+//# sourceMappingURL=task-contract.d.ts.map

package/dist/transition-engine.d.ts

@@ -0,0 +1,37 @@
+import type { WorkflowState } from './workflow-state.js';
+export declare const GOVERNANCE_ACTORS: readonly ['model', 'human', 'policy', 'system'];
+export type GovernanceActor = (typeof GOVERNANCE_ACTORS)[number];
+export type AuthorizationKind = 'none' | 'automatic' | 'human';
+export interface TransitionFacts {
+    readonly contractApproved: boolean;
+    readonly planApproved: boolean;
+    readonly withinAutonomyEnvelope: boolean;
+    readonly authorization: AuthorizationKind;
+    readonly executionGrantValid: boolean;
+    readonly snapshotCurrent: boolean;
+    readonly requiredEvidenceSatisfied: boolean;
+    readonly blockingFindings: number;
+    readonly rollbackVerified: boolean;
+}
+export interface TransitionProposal {
+    readonly from: WorkflowState;
+    readonly to: WorkflowState;
+    readonly actor: GovernanceActor;
+    readonly currentRevision: number;
+    readonly expectedRevision: number;
+    /** Trusted facts computed by governance adapters/policy, never copied from model arguments. */
+    readonly facts: TransitionFacts;
+}
+export type TransitionRejectionCode = 'stale_revision' | 'illegal_transition' | 'authorization_missing' | 'contract_not_approved' | 'plan_not_approved' | 'outside_autonomy_envelope' | 'execution_grant_missing' | 'stale_snapshot' | 'evidence_missing' | 'blocking_findings' | 'model_cannot_self_admit' | 'rollback_unverified';
+export type TransitionDecision = {
+    readonly allowed: true;
+    readonly from: WorkflowState;
+    readonly to: WorkflowState;
+    readonly nextRevision: number;
+} | {
+    readonly allowed: false;
+    readonly code: TransitionRejectionCode;
+    readonly message: string;
+};
+export declare function decideTransition(proposal: TransitionProposal): TransitionDecision;
+//# sourceMappingURL=transition-engine.d.ts.map

package/dist/verification-check-binding.d.ts

@@ -0,0 +1,23 @@
+import { type EvidenceKind } from './task-contract.js';
+export declare const VERIFICATION_CHECK_BINDING_SCHEMA_VERSION: 1;
+export interface VerificationCheckDescriptor {
+    readonly id: string;
+    readonly evidenceKind: EvidenceKind;
+    readonly handlerVersion: string;
+    readonly executionClass: 'trusted_deterministic';
+}
+export interface VerificationCheckBindingV1 {
+    readonly schemaVersion: typeof VERIFICATION_CHECK_BINDING_SCHEMA_VERSION;
+    readonly registryFingerprint: string;
+    readonly checkId: string;
+    readonly evidenceKind: EvidenceKind;
+    readonly handlerVersion: string;
+    readonly executionClass: 'trusted_deterministic';
+    readonly handlerFingerprint: string;
+}
+export declare function calculateVerificationCheckHandlerFingerprint(descriptor: VerificationCheckDescriptor): string;
+export declare function calculateVerificationCheckRegistryFingerprint(descriptors: readonly VerificationCheckDescriptor[]): string;
+export declare function createVerificationCheckBinding(registryFingerprint: string, descriptor: VerificationCheckDescriptor): VerificationCheckBindingV1;
+export declare function isVerificationCheckBindingIntegrityValid(binding: VerificationCheckBindingV1): boolean;
+export declare function verificationCheckBindingMatches(binding: VerificationCheckBindingV1, registryFingerprint: string, descriptor: VerificationCheckDescriptor): boolean;
+//# sourceMappingURL=verification-check-binding.d.ts.map

package/dist/verification-check-registry.d.ts

@@ -0,0 +1,43 @@
+import { type EvidenceKind } from './task-contract.js';
+import { type VerificationCheckBindingV1, type VerificationCheckDescriptor } from './verification-check-binding.js';
+import type { VerificationExecutionLeaseConsumption } from './verification-execution-lease.js';
+import { type VerificationRunContract } from './verification-run-contract.js';
+export declare const MAX_VERIFICATION_CHECK_REGISTRATIONS = 256;
+export interface FocusedVerificationExecutionContext {
+    readonly run: VerificationRunContract;
+    readonly consumption: VerificationExecutionLeaseConsumption;
+    readonly workspaceManifestHash: string;
+}
+export interface VerificationCheckRegistration<Result> extends VerificationCheckDescriptor {
+    readonly run: (context: FocusedVerificationExecutionContext) => Promise<Result>;
+}
+export type VerificationCheckRegistryDenialCode = 'check_not_registered' | 'evidence_kind_mismatch' | 'check_binding_missing' | 'check_binding_drifted' | 'execution_context_invalid';
+export type VerificationCheckBindingResolution = {
+    readonly bound: true;
+    readonly binding: VerificationCheckBindingV1;
+} | {
+    readonly bound: false;
+    readonly code: 'check_not_registered' | 'evidence_kind_mismatch';
+    readonly message: string;
+};
+export type VerificationCheckRegistryExecutionResult<Result> = {
+    readonly executed: false;
+    readonly code: VerificationCheckRegistryDenialCode;
+    readonly message: string;
+} | {
+    readonly executed: true;
+    readonly descriptor: VerificationCheckDescriptor;
+    readonly result: Result;
+};
+export declare class VerificationCheckRegistryConfigurationError extends Error {
+    constructor(message: string);
+}
+export declare class VerificationCheckRegistry<Result> {
+    #private;
+    constructor(registrations: readonly VerificationCheckRegistration<Result>[]);
+    list(): readonly VerificationCheckDescriptor[];
+    fingerprint(): string;
+    bindingFor(checkId: string, evidenceKind: EvidenceKind): VerificationCheckBindingResolution;
+    execute(context: FocusedVerificationExecutionContext): Promise<VerificationCheckRegistryExecutionResult<Result>>;
+}
+//# sourceMappingURL=verification-check-registry.d.ts.map