@wrongstack/governance 0.298.0

package/dist/daemon-launcher.d.ts

@@ -0,0 +1,46 @@
+import type { GovernanceServiceCredential } from './capability-grant.js';
+import type { GovernanceServiceCapability } from './service-protocol.js';
+export declare const GOVERNANCE_DAEMON_STARTUP_TIMEOUT_MS = 10000;
+export type GovernanceDaemonAvailability = {
+    readonly kind: 'available';
+    readonly entrypoint: URL;
+} | {
+    readonly kind: 'missing-build';
+};
+export type GovernanceDaemonLaunchErrorCode = 'missing_build' | 'spawn_failed' | 'startup_timeout' | 'startup_busy' | 'startup_failed' | 'owner_conflict' | 'endpoint_invalid' | 'invalid_handshake' | 'process_exited';
+export declare class GovernanceDaemonLaunchError extends Error {
+    readonly code: GovernanceDaemonLaunchErrorCode;
+    constructor(code: GovernanceDaemonLaunchErrorCode, message: string);
+}
+export interface LaunchGovernanceProjectDaemonOptions {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly clientId: string;
+    readonly capabilities: readonly GovernanceServiceCapability[];
+    readonly ttlMs: number;
+    readonly timeoutMs?: number | undefined;
+}
+export interface GovernanceProjectDaemonLaunch {
+    readonly pid: number;
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly instanceId: string;
+    readonly startedAt: string;
+    readonly grantId: string;
+    readonly expiresAt: string;
+    readonly credential: GovernanceServiceCredential;
+}
+interface GovernanceDaemonRuntime {
+    readonly entrypoint: URL;
+    readonly execArgv?: readonly string[] | undefined;
+    readonly cwd?: string | undefined;
+    readonly detached?: boolean | undefined;
+    readonly environment?: NodeJS.ProcessEnv | undefined;
+}
+export declare function governanceDaemonEnvironment(source: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export declare function resolveGovernanceDaemonAvailability(moduleUrl?: string, exists?: (filePath: string) => boolean): GovernanceDaemonAvailability;
+export declare function launchGovernanceProjectDaemon(options: LaunchGovernanceProjectDaemonOptions): Promise<GovernanceProjectDaemonLaunch>;
+/** Internal seam for source-level process tests; public callers use the built entrypoint above. */
+export declare function launchGovernanceProjectDaemonWithRuntime(options: LaunchGovernanceProjectDaemonOptions, runtime: GovernanceDaemonRuntime): Promise<GovernanceProjectDaemonLaunch>;
+export {};
+//# sourceMappingURL=daemon-launcher.d.ts.map

package/dist/daemon-metadata.d.ts

@@ -0,0 +1,126 @@
+import type { GovernanceServiceCredential } from './capability-grant.js';
+import { GOVERNANCE_SERVICE_PROTOCOL_VERSION } from './service-protocol.js';
+export declare const GOVERNANCE_DAEMON_METADATA_SCHEMA_VERSION: 1;
+export declare const GOVERNANCE_DAEMON_STARTUP_LEASE_SCHEMA_VERSION: 1;
+export declare const GOVERNANCE_DAEMON_ATTACHMENT_BROKER_SCHEMA_VERSION: 1;
+export declare const GOVERNANCE_DAEMON_METADATA_MAX_BYTES: number;
+export declare const GOVERNANCE_DAEMON_ENDPOINT_PROBE_TIMEOUT_MS = 750;
+export declare const GOVERNANCE_DAEMON_STARTUP_LEASE_TIMEOUT_MS = 10000;
+export declare const GOVERNANCE_DAEMON_STARTUP_LEASE_RETRY_MS = 50;
+export declare const GOVERNANCE_DAEMON_ATTACHMENT_BROKER_TTL_MS: number;
+export declare const GOVERNANCE_DAEMON_METADATA_RELATIVE_PATH: string;
+export declare const GOVERNANCE_DAEMON_STARTUP_LEASE_RELATIVE_PATH: string;
+export declare const GOVERNANCE_DAEMON_ATTACHMENT_BROKER_RELATIVE_PATH: string;
+export interface GovernanceDaemonMetadata {
+    readonly schemaVersion: typeof GOVERNANCE_DAEMON_METADATA_SCHEMA_VERSION;
+    readonly protocolVersion: typeof GOVERNANCE_SERVICE_PROTOCOL_VERSION;
+    readonly projectKey: string;
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly endpoint: string;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly startedAt: string;
+}
+export interface GovernanceDaemonStartupLeaseRecord {
+    readonly schemaVersion: typeof GOVERNANCE_DAEMON_STARTUP_LEASE_SCHEMA_VERSION;
+    readonly projectKey: string;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly startedAt: string;
+}
+export interface GovernanceDaemonAttachmentBrokerRecord {
+    readonly schemaVersion: typeof GOVERNANCE_DAEMON_ATTACHMENT_BROKER_SCHEMA_VERSION;
+    readonly protocolVersion: typeof GOVERNANCE_SERVICE_PROTOCOL_VERSION;
+    readonly projectKey: string;
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly grantId: string;
+    readonly expiresAt: string;
+    readonly credential: GovernanceServiceCredential;
+}
+export type GovernanceDaemonAttachmentBrokerReadResult = {
+    readonly kind: 'missing';
+} | {
+    readonly kind: 'invalid';
+    readonly reason: string;
+} | {
+    readonly kind: 'valid';
+    readonly broker: GovernanceDaemonAttachmentBrokerRecord;
+};
+export type GovernanceDaemonMetadataReadResult = {
+    readonly kind: 'missing';
+} | {
+    readonly kind: 'invalid';
+    readonly reason: string;
+} | {
+    readonly kind: 'valid';
+    readonly metadata: GovernanceDaemonMetadata;
+};
+export type GovernanceDaemonInspection = {
+    readonly kind: 'live';
+    readonly metadata: GovernanceDaemonMetadata;
+} | {
+    readonly kind: 'stale';
+    readonly metadata: GovernanceDaemonMetadata | null;
+    readonly metadataState: 'missing' | 'invalid' | 'dead-owner';
+} | {
+    readonly kind: 'endpoint_invalid';
+    readonly metadata: GovernanceDaemonMetadata | null;
+    readonly reason: string;
+};
+export type GovernanceDaemonStartupLeaseErrorCode = 'busy' | 'invalid_lease';
+export declare class GovernanceDaemonStartupLeaseError extends Error {
+    readonly code: GovernanceDaemonStartupLeaseErrorCode;
+    constructor(code: GovernanceDaemonStartupLeaseErrorCode, message: string);
+}
+interface AcquireGovernanceDaemonStartupLeaseOptions {
+    readonly projectRoot: string;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly startedAt: string;
+    readonly timeoutMs?: number | undefined;
+    readonly retryMs?: number | undefined;
+    readonly now?: (() => number) | undefined;
+    readonly isProcessAlive?: ((pid: number) => boolean) | undefined;
+}
+export declare function governanceDaemonMetadataPath(projectRoot: string): string;
+export declare function governanceDaemonStartupLeasePath(projectRoot: string): string;
+export declare function governanceDaemonAttachmentBrokerPath(projectRoot: string): string;
+export declare function createGovernanceDaemonAttachmentBroker(options: {
+    readonly metadata: GovernanceDaemonMetadata;
+    readonly grantId: string;
+    readonly expiresAt: string;
+    readonly credential: GovernanceServiceCredential;
+}): GovernanceDaemonAttachmentBrokerRecord;
+export declare function writeGovernanceDaemonAttachmentBroker(projectRoot: string, broker: GovernanceDaemonAttachmentBrokerRecord): Promise<void>;
+export declare function readGovernanceDaemonAttachmentBroker(projectRoot: string): Promise<GovernanceDaemonAttachmentBrokerReadResult>;
+export declare function removeOwnedGovernanceDaemonAttachmentBroker(projectRoot: string, owner: Pick<GovernanceDaemonMetadata, 'pid' | 'instanceId'>): Promise<boolean>;
+export declare function createGovernanceDaemonMetadata(options: {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly startedAt: string;
+}): GovernanceDaemonMetadata;
+export declare function writeGovernanceDaemonMetadata(projectRoot: string, metadata: GovernanceDaemonMetadata): Promise<void>;
+export declare function readGovernanceDaemonMetadata(projectRoot: string): Promise<GovernanceDaemonMetadataReadResult>;
+export declare function removeOwnedGovernanceDaemonMetadata(projectRoot: string, owner: Pick<GovernanceDaemonMetadata, 'pid' | 'instanceId'>): Promise<boolean>;
+export declare function isGovernanceProcessAlive(pid: number): boolean;
+export declare function probeGovernanceDaemonEndpoint(projectRoot: string, timeoutMs?: number): Promise<boolean>;
+export declare function inspectGovernanceDaemon(projectRoot: string): Promise<GovernanceDaemonInspection>;
+export declare function shouldRecoverGovernanceEndpoint(platform: NodeJS.Platform, inspection: GovernanceDaemonInspection): boolean;
+export declare class GovernanceDaemonStartupLease {
+    readonly projectRoot: string;
+    private readonly raw;
+    readonly path: string;
+    readonly record: GovernanceDaemonStartupLeaseRecord;
+    private released;
+    constructor(projectRoot: string, pathname: string, record: GovernanceDaemonStartupLeaseRecord, raw: string);
+    release(): Promise<boolean>;
+}
+export declare function acquireGovernanceDaemonStartupLease(options: AcquireGovernanceDaemonStartupLeaseOptions): Promise<GovernanceDaemonStartupLease>;
+export {};
+//# sourceMappingURL=daemon-metadata.d.ts.map

package/dist/daemon-protocol.d.ts

@@ -0,0 +1,59 @@
+import type { GovernanceServiceCredential } from './capability-grant.js';
+import { type GovernanceServiceCapability } from './service-protocol.js';
+export declare const GOVERNANCE_DAEMON_BOOTSTRAP_PROTOCOL_VERSION: 2;
+export interface GovernanceDaemonBootstrapRequest {
+    readonly type: 'bootstrap';
+    readonly protocolVersion: typeof GOVERNANCE_DAEMON_BOOTSTRAP_PROTOCOL_VERSION;
+    readonly nonce: string;
+    readonly clientId: string;
+    readonly capabilities: readonly GovernanceServiceCapability[];
+    readonly ttlMs: number;
+}
+export type GovernanceDaemonBootstrapErrorCode = 'invalid_bootstrap' | 'owner_conflict' | 'startup_busy' | 'endpoint_invalid' | 'startup_failed';
+export type GovernanceDaemonBootstrapMessage = {
+    readonly type: 'ready';
+    readonly protocolVersion: typeof GOVERNANCE_DAEMON_BOOTSTRAP_PROTOCOL_VERSION;
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly startedAt: string;
+} | {
+    readonly type: 'bootstrap_result';
+    readonly protocolVersion: typeof GOVERNANCE_DAEMON_BOOTSTRAP_PROTOCOL_VERSION;
+    readonly nonce: string;
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly pid: number;
+    readonly instanceId: string;
+    readonly startedAt: string;
+    readonly grantId: string;
+    readonly expiresAt: string;
+    readonly credential: GovernanceServiceCredential;
+} | {
+    readonly type: 'bootstrap_error';
+    readonly protocolVersion: typeof GOVERNANCE_DAEMON_BOOTSTRAP_PROTOCOL_VERSION;
+    readonly code: GovernanceDaemonBootstrapErrorCode;
+    readonly message: string;
+};
+export interface GovernanceDaemonProtocolIssue {
+    readonly path: string;
+    readonly message: string;
+}
+export type GovernanceDaemonBootstrapRequestDecodeResult = {
+    readonly decoded: true;
+    readonly request: GovernanceDaemonBootstrapRequest;
+} | {
+    readonly decoded: false;
+    readonly issues: readonly GovernanceDaemonProtocolIssue[];
+};
+export type GovernanceDaemonBootstrapMessageDecodeResult = {
+    readonly decoded: true;
+    readonly message: GovernanceDaemonBootstrapMessage;
+} | {
+    readonly decoded: false;
+    readonly issues: readonly GovernanceDaemonProtocolIssue[];
+};
+export declare function decodeGovernanceDaemonBootstrapRequest(input: unknown): GovernanceDaemonBootstrapRequestDecodeResult;
+export declare function decodeGovernanceDaemonBootstrapMessage(input: unknown): GovernanceDaemonBootstrapMessageDecodeResult;
+//# sourceMappingURL=daemon-protocol.d.ts.map

package/dist/event-store.d.ts

@@ -0,0 +1,109 @@
+import { type GovernanceCommand, type GovernanceCommandDecision, type GovernanceDecisionContext, type GovernanceEvent, type TaskAggregate } from './task-aggregate.js';
+import type { ConsumeVerificationExecutionLeaseResult, IssueVerificationExecutionLeaseResult, VerificationExecutionBinding, VerificationExecutionLeaseCredential, VerificationExecutionLeaseStatus, VerificationLeaseIssuancePrecondition } from './verification-execution-lease.js';
+import type { VerificationRunContract } from './verification-run-contract.js';
+import type { RecordWorkspaceSnapshotResult, WorkspaceSnapshotFenceDescriptor } from './workspace-snapshot-fence.js';
+export declare const GOVERNANCE_OBSERVATION_CATEGORIES: readonly ['task_created', 'status_changed', 'plan_updated', 'tool_invoked', 'evidence_candidate', 'verification_reported', 'review_reported', 'completion_claimed', 'failure_reported', 'capability_grant_issued', 'capability_grant_revoked', 'capability_grant_expired', 'capability_grant_rotated', 'daemon_attachment_broker_lifecycle', 'daemon_shutdown_requested'];
+export type GovernanceObservationCategory = (typeof GOVERNANCE_OBSERVATION_CATEGORIES)[number];
+export interface GovernanceObservation {
+    readonly observationId: string;
+    readonly projectId: string;
+    readonly taskId: string | null;
+    readonly source: string;
+    readonly category: GovernanceObservationCategory;
+    readonly observedAt: string;
+    readonly payload: Readonly<Record<string, unknown>>;
+}
+export interface StoredGovernanceObservation extends GovernanceObservation {
+    readonly sequence: number;
+    readonly recordedAt: string;
+}
+export type AppendGovernanceObservationResult = {
+    readonly handled: true;
+    readonly idempotentReplay: boolean;
+    readonly observation: StoredGovernanceObservation;
+} | {
+    readonly handled: false;
+    readonly code: 'observation_id_conflict';
+    readonly message: string;
+};
+export interface GovernanceCommandReceipt {
+    readonly commandId: string;
+    readonly taskId: string;
+    readonly command: GovernanceCommand;
+    readonly decisionContext: GovernanceDecisionContext;
+    readonly decision: GovernanceCommandDecision;
+    readonly resultRevision: number;
+    readonly recordedAt: string;
+}
+export type GovernanceCommandExecution = {
+    readonly handled: true;
+    readonly idempotentReplay: boolean;
+    readonly decision: GovernanceCommandDecision;
+    readonly aggregate: TaskAggregate | null;
+} | {
+    readonly handled: false;
+    readonly code: 'command_id_conflict';
+    readonly message: string;
+};
+export interface GovernanceEventStore {
+    execute(command: GovernanceCommand, context?: GovernanceDecisionContext): GovernanceCommandExecution;
+    readTask(taskId: string): TaskAggregate | null;
+    readEvents(taskId: string): readonly GovernanceEvent[];
+    readReceipt(commandId: string): GovernanceCommandReceipt | null;
+    appendObservation(observation: GovernanceObservation): AppendGovernanceObservationResult;
+    readObservations(projectId: string, taskId?: string): readonly StoredGovernanceObservation[];
+    readEvidenceCandidateObservations(projectId: string, taskId: string, options: {
+        readonly afterSequence: number;
+        readonly limit: number;
+    }): readonly StoredGovernanceObservation[];
+    recordWorkspaceSnapshot(projectId: string, manifestHash: string): RecordWorkspaceSnapshotResult;
+    readLatestWorkspaceSnapshot(projectId: string): WorkspaceSnapshotFenceDescriptor | null;
+    issueVerificationExecutionLease(run: VerificationRunContract): IssueVerificationExecutionLeaseResult;
+    issueVerificationExecutionLeaseIfCurrent(run: VerificationRunContract, precondition: VerificationLeaseIssuancePrecondition): IssueVerificationExecutionLeaseResult;
+    consumeVerificationExecutionLease(credential: VerificationExecutionLeaseCredential, binding: VerificationExecutionBinding): ConsumeVerificationExecutionLeaseResult;
+    readVerificationExecutionLeaseStatus(leaseId: string): VerificationExecutionLeaseStatus;
+    close(): void;
+}
+export interface SqliteGovernanceEventStoreOptions {
+    readonly now?: (() => string) | undefined;
+    readonly verificationLeaseSecret?: (() => string) | undefined;
+}
+export declare class GovernanceStoreCorruptionError extends Error {
+    constructor(message: string);
+}
+export declare class SqliteGovernanceEventStore implements GovernanceEventStore {
+    readonly databasePath: string;
+    private readonly db;
+    private readonly now;
+    private readonly verificationLedger;
+    private closed;
+    private constructor();
+    static open(databasePath: string, options?: SqliteGovernanceEventStoreOptions): SqliteGovernanceEventStore;
+    execute(command: GovernanceCommand, context?: GovernanceDecisionContext): GovernanceCommandExecution;
+    readTask(taskId: string): TaskAggregate | null;
+    readEvents(taskId: string): readonly GovernanceEvent[];
+    readReceipt(commandId: string): GovernanceCommandReceipt | null;
+    appendObservation(observation: GovernanceObservation): AppendGovernanceObservationResult;
+    readObservations(projectId: string, taskId?: string): readonly StoredGovernanceObservation[];
+    readEvidenceCandidateObservations(projectId: string, taskId: string, options: {
+        readonly afterSequence: number;
+        readonly limit: number;
+    }): readonly StoredGovernanceObservation[];
+    issueVerificationExecutionLease(run: VerificationRunContract): IssueVerificationExecutionLeaseResult;
+    recordWorkspaceSnapshot(projectId: string, manifestHash: string): RecordWorkspaceSnapshotResult;
+    readLatestWorkspaceSnapshot(projectId: string): WorkspaceSnapshotFenceDescriptor | null;
+    issueVerificationExecutionLeaseIfCurrent(run: VerificationRunContract, precondition: VerificationLeaseIssuancePrecondition): IssueVerificationExecutionLeaseResult;
+    consumeVerificationExecutionLease(credential: VerificationExecutionLeaseCredential, binding: VerificationExecutionBinding): ConsumeVerificationExecutionLeaseResult;
+    readVerificationExecutionLeaseStatus(leaseId: string): VerificationExecutionLeaseStatus;
+    close(): void;
+    private initializeSchema;
+    private readEventsUnlocked;
+    private readTaskUnlocked;
+    private readReceiptRow;
+    private readObservationRow;
+    private receiptFromRow;
+    private observationFromRow;
+    private executionFromReceipt;
+    private assertOpen;
+}
+//# sourceMappingURL=event-store.d.ts.map

package/dist/evidence-candidate.d.ts

@@ -0,0 +1,95 @@
+export declare const GOVERNANCE_EVIDENCE_CANDIDATE_SCHEMA_VERSION: 1;
+export declare const GOVERNANCE_EVIDENCE_CANDIDATE_DEFAULT_PAGE_SIZE = 50;
+export declare const GOVERNANCE_EVIDENCE_CANDIDATE_MAX_PAGE_SIZE = 100;
+export type GovernanceEvidenceCandidateMissingBinding = 'tool_call' | 'task' | 'plan' | 'workspace';
+export interface GovernanceEvidenceTraceSnapshot {
+    readonly sessionId: string;
+    readonly task: {
+        readonly scope: 'session';
+    } | {
+        readonly scope: 'kanban_task';
+        readonly taskId: string;
+        readonly boardId: string | null;
+    };
+    readonly plan: {
+        readonly state: 'missing' | 'invalid' | 'unreadable' | 'refreshing';
+    } | {
+        readonly state: 'available';
+        readonly fingerprint: string;
+    };
+    readonly workspace: {
+        readonly state: 'not_captured' | 'unavailable';
+    } | {
+        readonly state: 'captured';
+        readonly manifestHash: string;
+        readonly baseHead: string;
+    };
+}
+export interface GovernanceToolOutcomeMetadata {
+    readonly toolCallId?: string | undefined;
+    readonly toolName: string;
+    readonly ok: boolean;
+    readonly durationMs: number;
+    readonly outputBytes?: number | undefined;
+    readonly outputTokens?: number | undefined;
+    readonly outputLines?: number | undefined;
+}
+export interface GovernanceEvidenceCandidate {
+    readonly schemaVersion: typeof GOVERNANCE_EVIDENCE_CANDIDATE_SCHEMA_VERSION;
+    readonly candidateType: 'tool_execution';
+    readonly status: 'unverified';
+    readonly candidateId: string | null;
+    readonly binding: {
+        readonly state: 'bound';
+    } | {
+        readonly state: 'incomplete';
+        readonly missing: readonly GovernanceEvidenceCandidateMissingBinding[];
+    };
+    readonly tool: {
+        readonly callId: string | null;
+        readonly name: string;
+    };
+    readonly outcome: {
+        readonly status: 'succeeded' | 'failed';
+        readonly durationMs: number;
+        readonly outputBytes?: number | undefined;
+        readonly outputTokens?: number | undefined;
+        readonly outputLines?: number | undefined;
+    };
+}
+export type GovernanceEvidenceCandidateIneligibilityReason = 'payload_invalid' | 'unsupported_schema' | 'binding_incomplete' | 'candidate_identity_missing' | 'candidate_identity_mismatch' | 'task_binding_mismatch' | 'trace_binding_incomplete';
+export interface GovernanceEvidenceCandidateLedgerEntry {
+    readonly sequence: number;
+    readonly observationId: string;
+    readonly source: string;
+    readonly taskId: string | null;
+    readonly observedAt: string;
+    readonly recordedAt: string;
+    readonly candidateId: string | null;
+    readonly toolCallId: string | null;
+    readonly toolName: string | null;
+    readonly outcomeStatus: 'succeeded' | 'failed' | null;
+    readonly planFingerprint: string | null;
+    readonly workspaceManifestHash: string | null;
+    readonly workspaceBaseHead: string | null;
+    readonly evaluation: {
+        readonly state: 'eligible_for_evaluation';
+        readonly reasons: readonly GovernanceEvidenceCandidateIneligibilityReason[];
+    } | {
+        readonly state: 'ineligible';
+        readonly reasons: readonly GovernanceEvidenceCandidateIneligibilityReason[];
+    };
+}
+export interface GovernanceEvidenceCandidateObservation {
+    readonly sequence: number;
+    readonly observationId: string;
+    readonly source: string;
+    readonly taskId: string | null;
+    readonly category: string;
+    readonly observedAt: string;
+    readonly recordedAt: string;
+    readonly payload: Readonly<Record<string, unknown>>;
+}
+export declare function createGovernanceEvidenceCandidate(trace: GovernanceEvidenceTraceSnapshot, outcome: GovernanceToolOutcomeMetadata): GovernanceEvidenceCandidate;
+export declare function evaluateGovernanceEvidenceCandidateObservation(observation: GovernanceEvidenceCandidateObservation): GovernanceEvidenceCandidateLedgerEntry;
+//# sourceMappingURL=evidence-candidate.d.ts.map

package/dist/index.d.ts

@@ -0,0 +1,38 @@
+export * from './admin-session.js';
+export * from './attachment-broker-controller.js';
+export * from './authenticated-project-service.js';
+export * from './autonomy-envelope.js';
+export * from './capability-grant.js';
+export * from './credential-lease-controller.js';
+export * from './daemon-control.js';
+export type { GovernanceDaemonAvailability, GovernanceDaemonLaunchErrorCode, GovernanceProjectDaemonLaunch, LaunchGovernanceProjectDaemonOptions, } from './daemon-launcher.js';
+export { GOVERNANCE_DAEMON_STARTUP_TIMEOUT_MS, GovernanceDaemonLaunchError, governanceDaemonEnvironment, launchGovernanceProjectDaemon, resolveGovernanceDaemonAvailability, } from './daemon-launcher.js';
+export * from './daemon-metadata.js';
+export * from './daemon-protocol.js';
+export * from './event-store.js';
+export * from './evidence-candidate.js';
+export * from './ipc-endpoint.js';
+export * from './ipc-protocol.js';
+export * from './legacy-shadow-adapter.js';
+export * from './management-receipt-cache.js';
+export * from './plan-version.js';
+export * from './project-client.js';
+export * from './project-server.js';
+export * from './project-service.js';
+export * from './protocol-decoder.js';
+export { type ExistingGovernanceAdminCredential, GOVERNANCE_COMPATIBILITY_ADMIN_TTL_MS, GOVERNANCE_COMPATIBILITY_MODEL_TTL_MS, type GovernanceCompatibilityCleanup, type GovernanceCompatibilityFallback, type GovernanceCompatibilityFallbackCode, GovernanceCompatibilityRuntime, type GovernanceCompatibilityRuntimeSnapshot, type GovernanceModelCapability, GovernanceModelSession, type GovernanceModelSessionSnapshot, type PrepareGovernanceCompatibilityOptions, type PrepareGovernanceCompatibilityResult, prepareGovernanceCompatibilityRuntime, } from './runtime-compatibility.js';
+export * from './sanitize.js';
+export * from './task-aggregate.js';
+export * from './task-contract.js';
+export * from './transition-engine.js';
+export * from './verification-check-binding.js';
+export * from './verification-check-registry.js';
+export * from './verification-execution-lease.js';
+export * from './verification-issuance-coordinator.js';
+export * from './verification-ledger-store.js';
+export * from './verification-planner.js';
+export * from './verification-run-contract.js';
+export * from './verification-tool-gateway.js';
+export * from './workflow-state.js';
+export * from './workspace-snapshot-fence.js';
+//# sourceMappingURL=index.d.ts.map