@wrongstack/governance 0.298.0

package/dist/verification-execution-lease.d.ts

@@ -0,0 +1,76 @@
+import type { VerificationRunContract } from './verification-run-contract.js';
+import type { WorkspaceSnapshotFenceDescriptor } from './workspace-snapshot-fence.js';
+export declare const VERIFICATION_EXECUTION_LEASE_SCHEMA_VERSION: 1;
+export interface VerificationExecutionLeaseCredential {
+    readonly leaseId: string;
+    readonly secret: string;
+}
+export interface VerificationExecutionLeaseDescriptor {
+    readonly schemaVersion: typeof VERIFICATION_EXECUTION_LEASE_SCHEMA_VERSION;
+    readonly leaseId: string;
+    readonly runId: string;
+    readonly taskId: string;
+    readonly verifierClientId: string;
+    readonly issuedAt: string;
+    readonly expiresAt: string;
+}
+export interface VerificationExecutionBinding {
+    readonly runId: string;
+    readonly taskId: string;
+    readonly verifierClientId: string;
+    readonly planFingerprint: string;
+    readonly workspaceManifestHash: string;
+}
+export interface VerificationLeaseIssuancePrecondition {
+    readonly taskRevision: number;
+    readonly activeContractVersion: number;
+    readonly activePlanVersion: number;
+    readonly activePlanFingerprint: string;
+    readonly workflowState: 'proposed_complete' | 'verifying';
+    readonly workspaceManifestHash: string;
+    readonly workspaceSnapshot: WorkspaceSnapshotFenceDescriptor;
+    readonly candidateObservation: {
+        readonly sequence: number;
+        readonly observationId: string;
+    };
+}
+export interface VerificationExecutionLeaseConsumption {
+    readonly leaseId: string;
+    readonly runId: string;
+    readonly verifierClientId: string;
+    readonly consumedAt: string;
+    readonly bindingHash: string;
+}
+export type IssueVerificationExecutionLeaseResult = {
+    readonly issued: true;
+    readonly run: VerificationRunContract;
+    readonly lease: VerificationExecutionLeaseDescriptor;
+    readonly credential: VerificationExecutionLeaseCredential;
+} | {
+    readonly issued: false;
+    readonly code: 'run_invalid' | 'run_conflict' | 'run_expired' | 'already_issued' | 'canonical_task_missing' | 'canonical_state_invalid' | 'canonical_state_mismatch' | 'canonical_candidate_missing' | 'canonical_candidate_invalid' | 'canonical_candidate_mismatch' | 'workspace_snapshot_missing' | 'workspace_snapshot_invalid' | 'workspace_snapshot_stale' | 'workspace_mismatch';
+    readonly message: string;
+};
+export type ConsumeVerificationExecutionLeaseResult = {
+    readonly authorized: true;
+    readonly run: VerificationRunContract;
+    readonly consumption: VerificationExecutionLeaseConsumption;
+} | {
+    readonly authorized: false;
+    readonly code: 'invalid_credential' | 'already_consumed' | 'expired' | 'binding_mismatch' | 'stored_run_invalid';
+    readonly message: string;
+};
+export type VerificationExecutionLeaseStatus = {
+    readonly state: 'missing';
+    readonly leaseId: string;
+} | {
+    readonly state: 'active' | 'expired' | 'consumed';
+    readonly lease: VerificationExecutionLeaseDescriptor;
+    readonly consumption: VerificationExecutionLeaseConsumption | null;
+};
+export declare function verificationExecutionLeaseId(runId: string): string;
+export declare function createVerificationExecutionLeaseSecret(): string;
+export declare function verificationExecutionLeaseSecretHash(secret: string): string;
+export declare function verificationExecutionBindingHash(binding: VerificationExecutionBinding): string;
+export declare function verificationExecutionLeaseSecretMatches(secret: string, expectedHash: string): boolean;
+//# sourceMappingURL=verification-execution-lease.d.ts.map

package/dist/verification-issuance-coordinator.d.ts

@@ -0,0 +1,110 @@
+import type { GovernanceEventStore } from './event-store.js';
+import type { GovernanceEvidenceCandidateLedgerEntry } from './evidence-candidate.js';
+import type { TaskAggregate } from './task-aggregate.js';
+import type { EvidenceKind } from './task-contract.js';
+import type { VerificationCheckBindingResolution } from './verification-check-registry.js';
+import type { IssueVerificationExecutionLeaseResult } from './verification-execution-lease.js';
+import type { VerificationPlanDraftV1 } from './verification-planner.js';
+import { type VerificationRunIssuanceIssue, type VerificationRunRequestV1 } from './verification-run-contract.js';
+export type VerificationIssuanceCoordinatorMode = 'legacy' | 'enforced';
+export interface VerificationCheckBindingResolver {
+    bindingFor(checkId: string, evidenceKind: EvidenceKind): VerificationCheckBindingResolution;
+}
+export interface VerificationExecutionLeaseIssuer {
+    issueVerificationExecutionLeaseIfCurrent: GovernanceEventStore['issueVerificationExecutionLeaseIfCurrent'];
+    recordWorkspaceSnapshot?: GovernanceEventStore['recordWorkspaceSnapshot'];
+}
+export interface VerificationWorkspaceSnapshotRecorder {
+    recordWorkspaceSnapshot: GovernanceEventStore['recordWorkspaceSnapshot'];
+}
+export interface VerificationIssuanceCoordinatorOptions {
+    /** Defaults to legacy; construction alone cannot enable governed issuance. */
+    readonly mode?: VerificationIssuanceCoordinatorMode | undefined;
+    readonly verifierClientId: string;
+    readonly ttlMs: number;
+    readonly maxDurationMs: number;
+    readonly now: () => string;
+    readonly captureWorkspaceIdentity: () => Promise<{
+        readonly manifestHash: string;
+    }>;
+    readonly workspaceSnapshots?: VerificationWorkspaceSnapshotRecorder | undefined;
+    readonly checkBindings: VerificationCheckBindingResolver;
+    readonly leaseIssuer: VerificationExecutionLeaseIssuer;
+}
+export interface VerificationIssuanceCoordinatorInput {
+    readonly task: TaskAggregate | null;
+    readonly draft: VerificationPlanDraftV1;
+    readonly candidates: readonly GovernanceEvidenceCandidateLedgerEntry[];
+    /** The complete model-proposable surface. Registry bindings are not accepted here. */
+    readonly request: VerificationRunRequestV1;
+}
+type VerificationLeaseFailure = Extract<IssueVerificationExecutionLeaseResult, {
+    issued: false;
+}>;
+type VerificationLeaseSuccess = Extract<IssueVerificationExecutionLeaseResult, {
+    issued: true;
+}>;
+export type VerificationIssuanceCoordinatorResult = {
+    readonly route: 'legacy';
+    readonly handled: false;
+    readonly reason: 'coordinator_disabled';
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly issued: false;
+    readonly phase: 'authority';
+    readonly code: 'authority_unavailable';
+    readonly message: string;
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly issued: false;
+    readonly phase: 'workspace';
+    readonly code: 'workspace_identity_unavailable' | 'workspace_mismatch' | 'workspace_snapshot_unavailable' | 'workspace_snapshot_invalid';
+    readonly message: string;
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly issued: false;
+    readonly phase: 'run_contract';
+    readonly issues: readonly VerificationRunIssuanceIssue[];
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly issued: false;
+    readonly phase: 'check_registry';
+    readonly code: Extract<VerificationCheckBindingResolution, {
+        bound: false;
+    }>['code'] | 'check_registry_unavailable';
+    readonly message: string;
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly issued: false;
+    readonly phase: 'internal';
+    readonly code: 'bound_run_invariant_failed' | 'lease_result_mismatch';
+    readonly message: string;
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly issued: false;
+    readonly phase: 'lease';
+    readonly code: VerificationLeaseFailure['code'] | 'lease_unavailable';
+    readonly message: string;
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly issued: true;
+    readonly run: Extract<VerificationLeaseSuccess['run'], {
+        schemaVersion: 2;
+    }>;
+    readonly lease: VerificationLeaseSuccess['lease'];
+    readonly credential: VerificationLeaseSuccess['credential'];
+};
+export declare class VerificationIssuanceCoordinator {
+    #private;
+    constructor(options: VerificationIssuanceCoordinatorOptions);
+    issue(input: VerificationIssuanceCoordinatorInput): Promise<VerificationIssuanceCoordinatorResult>;
+}
+export {};
+//# sourceMappingURL=verification-issuance-coordinator.d.ts.map

package/dist/verification-ledger-store.d.ts

@@ -0,0 +1,20 @@
+import type { DatabaseSync } from 'node:sqlite';
+import { type ConsumeVerificationExecutionLeaseResult, type IssueVerificationExecutionLeaseResult, type VerificationExecutionBinding, type VerificationExecutionLeaseCredential, type VerificationExecutionLeaseStatus, type VerificationLeaseIssuancePrecondition } from './verification-execution-lease.js';
+import { type VerificationRunContract } from './verification-run-contract.js';
+import { type RecordWorkspaceSnapshotResult, type WorkspaceSnapshotFenceDescriptor } from './workspace-snapshot-fence.js';
+export interface SqliteVerificationLedgerOptions {
+    readonly now: () => string;
+    readonly verificationLeaseSecret?: (() => string) | undefined;
+}
+export declare class SqliteVerificationLedger {
+    #private;
+    constructor(db: DatabaseSync, options: SqliteVerificationLedgerOptions);
+    initializeSchema(): void;
+    recordWorkspaceSnapshot(projectId: string, manifestHash: string): RecordWorkspaceSnapshotResult;
+    readLatestWorkspaceSnapshot(projectId: string): WorkspaceSnapshotFenceDescriptor | null;
+    issue(run: VerificationRunContract): IssueVerificationExecutionLeaseResult;
+    issueIfCurrent(run: VerificationRunContract, precondition: VerificationLeaseIssuancePrecondition): IssueVerificationExecutionLeaseResult;
+    consume(credential: VerificationExecutionLeaseCredential, binding: VerificationExecutionBinding): ConsumeVerificationExecutionLeaseResult;
+    readStatus(leaseId: string): VerificationExecutionLeaseStatus;
+}
+//# sourceMappingURL=verification-ledger-store.d.ts.map

package/dist/verification-planner.d.ts

@@ -0,0 +1,76 @@
+import type { GovernanceEvidenceCandidateLedgerEntry } from './evidence-candidate.js';
+import type { TaskAggregate } from './task-aggregate.js';
+import { type EvidenceKind } from './task-contract.js';
+export declare const VERIFICATION_PLANNER_INPUT_SCHEMA_VERSION: 1;
+export declare const VERIFICATION_PLAN_DRAFT_SCHEMA_VERSION: 1;
+export declare const MAX_VERIFICATION_CANDIDATE_PROPOSALS = 512;
+export interface VerificationPlanningScopeV1 {
+    readonly taskId: string;
+    readonly contractVersion: number;
+    readonly planFingerprint: string;
+    readonly workspaceManifestHash: string;
+}
+export interface VerificationCandidateProposalV1 {
+    readonly requiredCheckId: string;
+    readonly candidateId: string;
+}
+export interface VerificationPlannerInputV1 {
+    readonly schemaVersion: typeof VERIFICATION_PLANNER_INPUT_SCHEMA_VERSION;
+    readonly scope: VerificationPlanningScopeV1;
+    readonly proposals: readonly VerificationCandidateProposalV1[];
+}
+export type VerificationPlannerIssueCode = 'task_missing' | 'active_contract_missing' | 'contract_invalid' | 'invalid_schema_version' | 'task_mismatch' | 'contract_version_mismatch' | 'scope_identity_invalid' | 'proposal_limit_exceeded';
+export interface VerificationPlannerIssue {
+    readonly code: VerificationPlannerIssueCode;
+    readonly path: string;
+    readonly message: string;
+}
+export type VerificationProposalRejectionCode = 'proposal_invalid' | 'duplicate_proposal' | 'unknown_required_check' | 'candidate_missing' | 'candidate_ambiguous' | 'candidate_ineligible' | 'candidate_task_mismatch' | 'candidate_plan_mismatch' | 'candidate_workspace_mismatch';
+export type VerificationProposalDisposition = {
+    readonly state: 'accepted_as_proposal';
+    readonly requiredCheckId: string;
+    readonly candidateId: string;
+} | {
+    readonly state: 'rejected';
+    readonly requiredCheckId: string | null;
+    readonly candidateId: string | null;
+    readonly code: VerificationProposalRejectionCode;
+    readonly path: string;
+};
+export interface VerificationCheckDraftV1 {
+    readonly requiredCheckId: string;
+    readonly expectedEvidenceKind: EvidenceKind;
+    readonly required: boolean;
+    readonly requirementIds: readonly string[];
+    readonly acceptanceCriterionIds: readonly string[];
+    readonly state: 'unassigned' | 'candidates_proposed';
+    readonly proposedCandidateIds: readonly string[];
+    /** A proposed tool result is never sufficient evidence by itself. */
+    readonly evidenceSatisfied: false;
+}
+export interface VerificationPlanDraftV1 {
+    readonly schemaVersion: typeof VERIFICATION_PLAN_DRAFT_SCHEMA_VERSION;
+    readonly draftId: string;
+    readonly status: 'draft';
+    readonly scope: VerificationPlanningScopeV1;
+    readonly checks: readonly VerificationCheckDraftV1[];
+    readonly proposalDispositions: readonly VerificationProposalDisposition[];
+    readonly summary: {
+        readonly requiredCheckCount: number;
+        readonly requiredChecksWithCandidates: number;
+        readonly allRequiredChecksHaveCandidates: boolean;
+        readonly requiredEvidenceSatisfied: false;
+        readonly nextAction: 'repropose_candidates' | 'independent_verification';
+    };
+}
+export type VerificationPlanningResult = {
+    readonly planned: false;
+    readonly issues: readonly VerificationPlannerIssue[];
+} | {
+    readonly planned: true;
+    readonly issues: readonly VerificationPlannerIssue[];
+    readonly draft: VerificationPlanDraftV1;
+};
+export declare function calculateVerificationPlanDraftId(draft: Pick<VerificationPlanDraftV1, 'schemaVersion' | 'status' | 'scope' | 'checks'>): string;
+export declare function buildVerificationPlanDraft(task: TaskAggregate | null, candidates: readonly GovernanceEvidenceCandidateLedgerEntry[], input: VerificationPlannerInputV1): VerificationPlanningResult;
+//# sourceMappingURL=verification-planner.d.ts.map

package/dist/verification-run-contract.d.ts

@@ -0,0 +1,84 @@
+import { type AutonomyTier } from './autonomy-envelope.js';
+import type { GovernanceEvidenceCandidateLedgerEntry } from './evidence-candidate.js';
+import type { TaskAggregate } from './task-aggregate.js';
+import { type EvidenceKind } from './task-contract.js';
+import { type VerificationCheckBindingV1 } from './verification-check-binding.js';
+import { type VerificationPlanDraftV1 } from './verification-planner.js';
+export declare const VERIFICATION_RUN_REQUEST_SCHEMA_VERSION: 1;
+export declare const VERIFICATION_RUN_CONTRACT_V1_SCHEMA_VERSION: 1;
+export declare const VERIFICATION_RUN_CONTRACT_SCHEMA_VERSION: 2;
+export declare const MAX_VERIFICATION_RUN_TTL_MS: number;
+export declare const MAX_VERIFICATION_RUN_DURATION_MS: number;
+export interface VerificationRunRequestV1 {
+    readonly schemaVersion: typeof VERIFICATION_RUN_REQUEST_SCHEMA_VERSION;
+    readonly draftId: string;
+    readonly requiredCheckId: string;
+    readonly candidateId: string;
+}
+/** Supplied by the deterministic daemon/transport, never by the model request payload. */
+export interface VerificationRunAuthorityContext {
+    readonly verifierClientId: string;
+    readonly issuedAt: string;
+    readonly ttlMs: number;
+    readonly maxDurationMs: number;
+}
+export interface BoundVerificationRunAuthorityContext extends VerificationRunAuthorityContext {
+    /** Derived from the trusted immutable registry, never from the model request. */
+    readonly checkBinding: VerificationCheckBindingV1;
+}
+export interface VerificationRunContractV1 {
+    readonly schemaVersion: typeof VERIFICATION_RUN_CONTRACT_V1_SCHEMA_VERSION;
+    readonly runId: string;
+    readonly status: 'authorized';
+    readonly draftId: string;
+    readonly taskId: string;
+    readonly contractVersion: number;
+    readonly planFingerprint: string;
+    readonly workspaceManifestHash: string;
+    readonly requiredCheckId: string;
+    readonly expectedEvidenceKind: EvidenceKind;
+    readonly candidateId: string;
+    readonly candidateSource: string;
+    readonly verifierClientId: string;
+    readonly authorization: {
+        readonly operation: 'focused_check';
+        readonly mode: 'automatic';
+        readonly autonomyTier: AutonomyTier;
+    };
+    readonly limits: {
+        readonly issuedAt: string;
+        readonly expiresAt: string;
+        readonly ttlMs: number;
+        readonly maxDurationMs: number;
+    };
+    readonly resultPolicy: {
+        readonly executorMayApprove: false;
+        readonly independentToolEvidenceRequired: true;
+        readonly freshWorkspaceIdentityRequired: true;
+    };
+}
+export interface VerificationRunContractV2 extends Omit<VerificationRunContractV1, 'schemaVersion' | 'runId'> {
+    readonly schemaVersion: typeof VERIFICATION_RUN_CONTRACT_SCHEMA_VERSION;
+    readonly runId: string;
+    readonly checkBinding: VerificationCheckBindingV1;
+}
+export type VerificationRunContract = VerificationRunContractV1 | VerificationRunContractV2;
+export type VerificationRunContractWithoutId = Omit<VerificationRunContractV1, 'runId'> | Omit<VerificationRunContractV2, 'runId'>;
+export type VerificationRunIssuanceIssueCode = 'task_missing' | 'active_contract_missing' | 'workflow_state_invalid' | 'draft_invalid' | 'draft_scope_mismatch' | 'request_invalid' | 'required_check_missing' | 'required_check_drifted' | 'candidate_not_proposed' | 'candidate_missing' | 'candidate_ambiguous' | 'candidate_ineligible' | 'candidate_scope_mismatch' | 'verifier_identity_invalid' | 'verifier_not_independent' | 'operation_not_authorized' | 'check_binding_invalid' | 'check_binding_mismatch' | 'authority_time_invalid' | 'authority_limits_invalid';
+export interface VerificationRunIssuanceIssue {
+    readonly code: VerificationRunIssuanceIssueCode;
+    readonly path: string;
+    readonly message: string;
+}
+export type VerificationRunIssuanceResult = {
+    readonly issued: true;
+    readonly contract: VerificationRunContract;
+} | {
+    readonly issued: false;
+    readonly issues: readonly VerificationRunIssuanceIssue[];
+};
+export declare function calculateVerificationRunId(contract: VerificationRunContractWithoutId): string;
+export declare function isVerificationRunContractIntegrityValid(contract: VerificationRunContract): boolean;
+export declare function issueVerificationRunContract(task: TaskAggregate | null, draft: VerificationPlanDraftV1, candidates: readonly GovernanceEvidenceCandidateLedgerEntry[], request: VerificationRunRequestV1, authority: VerificationRunAuthorityContext): VerificationRunIssuanceResult;
+export declare function issueBoundVerificationRunContract(task: TaskAggregate | null, draft: VerificationPlanDraftV1, candidates: readonly GovernanceEvidenceCandidateLedgerEntry[], request: VerificationRunRequestV1, authority: BoundVerificationRunAuthorityContext): VerificationRunIssuanceResult;
+//# sourceMappingURL=verification-run-contract.d.ts.map

package/dist/verification-tool-gateway.d.ts

@@ -0,0 +1,74 @@
+import type { GovernanceEventStore } from './event-store.js';
+import type { VerificationCheckDescriptor } from './verification-check-binding.js';
+import type { VerificationCheckRegistry, VerificationCheckRegistryDenialCode } from './verification-check-registry.js';
+import type { ConsumeVerificationExecutionLeaseResult, VerificationExecutionLeaseConsumption, VerificationExecutionLeaseCredential } from './verification-execution-lease.js';
+import type { VerificationRunContract } from './verification-run-contract.js';
+export declare const VERIFICATION_TOOL_GATEWAY_REQUEST_SCHEMA_VERSION: 1;
+export type VerificationToolGatewayMode = 'legacy' | 'enforced';
+/**
+ * Contains only canonical identities and a one-time credential. Tool names,
+ * commands, paths, and arguments are deliberately not accepted at this boundary.
+ */
+export interface VerificationToolGatewayRequestV1 {
+    readonly schemaVersion: typeof VERIFICATION_TOOL_GATEWAY_REQUEST_SCHEMA_VERSION;
+    readonly credential: VerificationExecutionLeaseCredential;
+    readonly expected: {
+        readonly runId: string;
+        readonly taskId: string;
+        readonly planFingerprint: string;
+    };
+}
+export interface VerificationWorkspaceIdentity {
+    readonly manifestHash: string;
+}
+export interface VerificationExecutionLeaseConsumer {
+    consumeVerificationExecutionLease: GovernanceEventStore['consumeVerificationExecutionLease'];
+}
+export interface VerificationToolGatewayOptions<Result> {
+    /** Defaults to legacy so construction alone can never enable enforcement. */
+    readonly mode?: VerificationToolGatewayMode | undefined;
+    readonly verifierClientId: string;
+    readonly leaseConsumer: VerificationExecutionLeaseConsumer;
+    readonly captureWorkspaceIdentity: () => Promise<VerificationWorkspaceIdentity>;
+    readonly checkRegistry: VerificationCheckRegistry<Result>;
+}
+type VerificationLeaseDenialCode = Extract<ConsumeVerificationExecutionLeaseResult, {
+    readonly authorized: false;
+}>['code'];
+type VerificationToolGatewayDenialCode = VerificationLeaseDenialCode | 'request_invalid' | 'workspace_identity_unavailable';
+export type VerificationToolGatewayResult<Result> = {
+    readonly route: 'legacy';
+    readonly handled: false;
+    readonly reason: 'gateway_disabled';
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly authorized: false;
+    readonly code: VerificationToolGatewayDenialCode;
+    readonly message: string;
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly authorized: true;
+    readonly outcome: 'succeeded';
+    readonly run: VerificationRunContract;
+    readonly consumption: VerificationExecutionLeaseConsumption;
+    readonly check: VerificationCheckDescriptor;
+    readonly result: Result;
+} | {
+    readonly route: 'governed';
+    readonly handled: true;
+    readonly authorized: true;
+    readonly outcome: 'failed';
+    readonly code: 'focused_check_failed' | VerificationCheckRegistryDenialCode;
+    readonly message: string;
+    readonly run: VerificationRunContract;
+    readonly consumption: VerificationExecutionLeaseConsumption;
+};
+export declare class VerificationToolGateway<Result> {
+    #private;
+    constructor(options: VerificationToolGatewayOptions<Result>);
+    execute(request: VerificationToolGatewayRequestV1): Promise<VerificationToolGatewayResult<Result>>;
+}
+export {};
+//# sourceMappingURL=verification-tool-gateway.d.ts.map

package/dist/workflow-state.d.ts

@@ -0,0 +1,5 @@
+export declare const WORKFLOW_STATES: readonly ['draft', 'scoped', 'planned', 'authorized', 'executing', 'proposed_complete', 'verifying', 'reviewing', 'ready_to_merge', 'completed', 'blocked', 'replan_requested', 'rolling_back', 'rolled_back', 'rollback_failed', 'failed', 'cancelled'];
+export type WorkflowState = (typeof WORKFLOW_STATES)[number];
+export declare function isTerminalWorkflowState(state: WorkflowState): boolean;
+export declare function isSuccessfulWorkflowState(state: WorkflowState): boolean;
+//# sourceMappingURL=workflow-state.d.ts.map

package/dist/workspace-snapshot-fence.d.ts

@@ -0,0 +1,20 @@
+export declare const WORKSPACE_SNAPSHOT_FENCE_SCHEMA_VERSION: 1;
+export interface WorkspaceSnapshotFenceDescriptor {
+    readonly schemaVersion: typeof WORKSPACE_SNAPSHOT_FENCE_SCHEMA_VERSION;
+    readonly snapshotId: string;
+    readonly projectId: string;
+    readonly revision: number;
+    readonly manifestHash: string;
+    readonly capturedAt: string;
+}
+export type RecordWorkspaceSnapshotResult = {
+    readonly recorded: true;
+    readonly snapshot: WorkspaceSnapshotFenceDescriptor;
+} | {
+    readonly recorded: false;
+    readonly code: 'workspace_snapshot_invalid';
+    readonly message: string;
+};
+export declare function workspaceSnapshotFenceId(projectId: string, revision: number, manifestHash: string, capturedAt: string): string;
+export declare function isWorkspaceSnapshotFenceDescriptorValid(snapshot: WorkspaceSnapshotFenceDescriptor): boolean;
+//# sourceMappingURL=workspace-snapshot-fence.d.ts.map

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@wrongstack/governance",
+  "version": "0.298.0",
+  "license": "MIT",
+  "description": "Deterministic workflow contracts and transition policy for WrongStack orchestration.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/WrongStack/WrongStack.git",
+    "directory": "packages/governance"
+  },
+  "homepage": "https://github.com/WrongStack/WrongStack#readme",
+  "bugs": "https://github.com/WrongStack/WrongStack/issues",
+  "author": "ECOSTACK TECHNOLOGY OÜ",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "!dist/**/*.map",
+    "README.md"
+  ],
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "node ../../scripts/build-package.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --root ../.. packages/governance/tests",
+    "clean": "node -e \"require('node:fs').rmSync('dist',{recursive:true,force:true})\""
+  }
+}