@wrongstack/governance 0.298.0

package/dist/ipc-endpoint.d.ts

@@ -0,0 +1,6 @@
+export declare const GOVERNANCE_DATABASE_RELATIVE_PATH: string;
+export declare function canonicalGovernanceProjectRoot(projectRoot: string): string;
+export declare function governanceProjectKey(projectRoot: string): string;
+export declare function governanceProjectServerEndpoint(projectRoot: string): string;
+export declare function governanceProjectDatabasePath(projectRoot: string): string;
+//# sourceMappingURL=ipc-endpoint.d.ts.map

package/dist/ipc-protocol.d.ts

@@ -0,0 +1,24 @@
+import type { GovernanceServiceCredential } from './capability-grant.js';
+import type { GovernanceServiceResponse } from './project-service.js';
+import { GOVERNANCE_SERVICE_PROTOCOL_VERSION } from './service-protocol.js';
+export declare const GOVERNANCE_IPC_MAX_FRAME_BYTES: number;
+export interface GovernanceIpcRequestEnvelope {
+    readonly protocolVersion: typeof GOVERNANCE_SERVICE_PROTOCOL_VERSION;
+    readonly credential: GovernanceServiceCredential;
+    readonly request: unknown;
+}
+export interface GovernanceIpcDecodeIssue {
+    readonly path: string;
+    readonly message: string;
+}
+export type GovernanceIpcEnvelopeDecodeResult = {
+    readonly decoded: true;
+    readonly envelope: GovernanceIpcRequestEnvelope;
+} | {
+    readonly decoded: false;
+    readonly issues: readonly GovernanceIpcDecodeIssue[];
+};
+export declare function decodeGovernanceIpcEnvelope(input: unknown): GovernanceIpcEnvelopeDecodeResult;
+export declare function encodeGovernanceIpcFrame(value: unknown): Buffer;
+export declare function decodeGovernanceIpcResponse(input: unknown): GovernanceServiceResponse;
+//# sourceMappingURL=ipc-protocol.d.ts.map

package/dist/legacy-shadow-adapter.d.ts

@@ -0,0 +1,33 @@
+import type { AuthenticatedGovernanceProjectService } from './authenticated-project-service.js';
+import type { GovernanceServiceCredential } from './capability-grant.js';
+import type { GovernanceObservationCategory, StoredGovernanceObservation } from './event-store.js';
+export interface LegacyRuntimeObservation {
+    readonly observationId: string;
+    readonly taskId?: string | undefined;
+    readonly category: GovernanceObservationCategory;
+    readonly observedAt: string;
+    readonly payload: Readonly<Record<string, unknown>>;
+}
+export type LegacyShadowObservationResult = {
+    readonly observed: true;
+    readonly idempotentReplay: boolean;
+    readonly observation: StoredGovernanceObservation;
+} | {
+    readonly observed: false;
+    readonly code: string;
+    readonly message: string;
+};
+/**
+ * Observe-only compatibility adapter. It can append shadow observations but has no command capability
+ * and therefore cannot create tasks, transition canonical state, or block the legacy runtime.
+ */
+export declare class LegacyGovernanceShadowAdapter {
+    private readonly service;
+    private readonly source;
+    private readonly credential;
+    private requestSequence;
+    constructor(service: AuthenticatedGovernanceProjectService, source: string, credential: GovernanceServiceCredential);
+    observe(observation: LegacyRuntimeObservation): LegacyShadowObservationResult;
+    private toResult;
+}
+//# sourceMappingURL=legacy-shadow-adapter.d.ts.map

package/dist/management-receipt-cache.d.ts

@@ -0,0 +1,53 @@
+import type { GovernanceServiceCredential } from './capability-grant.js';
+import type { GovernanceServiceResponse } from './project-service.js';
+export declare const GOVERNANCE_MANAGEMENT_RECEIPT_TTL_MS = 30000;
+export declare const GOVERNANCE_MANAGEMENT_RECEIPT_MAX_ENTRIES = 1024;
+export interface GovernanceManagementReceiptCacheOptions {
+    readonly now?: (() => number) | undefined;
+    readonly ttlMs?: number | undefined;
+    readonly maxEntries?: number | undefined;
+}
+export type GovernanceManagementReceiptLookup = {
+    readonly kind: 'miss';
+} | {
+    readonly kind: 'in_progress';
+} | {
+    readonly kind: 'conflict';
+    readonly allowAfterRotation: boolean;
+} | {
+    readonly kind: 'replay';
+    readonly response: GovernanceServiceResponse;
+    readonly allowAfterRotation: boolean;
+};
+export interface GovernanceManagementReceiptReservation {
+    readonly key: string;
+    readonly fingerprint: string;
+    readonly requestId: string;
+}
+export declare class GovernanceManagementReceiptCache {
+    private readonly now;
+    private readonly ttlMs;
+    private readonly maxEntries;
+    private readonly records;
+    constructor(options?: GovernanceManagementReceiptCacheOptions);
+    lookup(input: unknown, credential: GovernanceServiceCredential): GovernanceManagementReceiptLookup;
+    reserve(options: {
+        readonly input: unknown;
+        readonly credential: GovernanceServiceCredential;
+        /**
+         * Raw wire payload to fingerprint for replay-conflict detection. Must be
+         * the same form that subsequent `lookup` calls see; defaults to `input`
+         * when the caller has no separate wire form. Passing the raw form (and
+         * not the decoder-normalized form) keeps the contract immune to a future
+         * decoder that adds content-preserving normalization, which would
+         * otherwise turn every legitimate retry into a misleading
+         * "requestId already used" conflict.
+         */
+        readonly wireInput?: unknown;
+    }): GovernanceManagementReceiptReservation | null;
+    commit(reservation: GovernanceManagementReceiptReservation, response: GovernanceServiceResponse, allowAfterRotation?: boolean): void;
+    release(reservation: GovernanceManagementReceiptReservation): void;
+    clear(): void;
+    private pruneExpired;
+}
+//# sourceMappingURL=management-receipt-cache.d.ts.map

package/dist/plan-version.d.ts

@@ -0,0 +1,91 @@
+import { type GovernedOperation, type OperationAutonomyDecision } from './autonomy-envelope.js';
+import { type TaskContractV1 } from './task-contract.js';
+export declare const PLAN_VERSION_SCHEMA_VERSION: 1;
+export interface PlanStepV1 {
+    readonly id: string;
+    readonly title: string;
+    readonly description: string;
+    readonly operations: readonly GovernedOperation[];
+    readonly expectedPaths: readonly string[];
+    readonly requirementIds: readonly string[];
+    readonly acceptanceCriteriaIds: readonly string[];
+    readonly requiredCheckIds: readonly string[];
+}
+export interface PlanEdgeV1 {
+    readonly fromStepId: string;
+    readonly toStepId: string;
+}
+export interface PlanVersionV1 {
+    readonly schemaVersion: typeof PLAN_VERSION_SCHEMA_VERSION;
+    readonly planId: string;
+    readonly taskId: string;
+    readonly planVersion: number;
+    readonly parentPlanVersion: number | null;
+    readonly contractVersion: number;
+    readonly createdBy: 'model' | 'human' | 'policy' | 'system';
+    readonly createdAt: string;
+    readonly changeReason: string;
+    readonly steps: readonly PlanStepV1[];
+    readonly edges: readonly PlanEdgeV1[];
+}
+export declare function calculatePlanVersionFingerprint(plan: PlanVersionV1): string;
+export interface PlanStepAutonomy {
+    readonly stepId: string;
+    readonly automatic: boolean;
+    readonly decisions: readonly OperationAutonomyDecision[];
+}
+export interface PlanAutonomySummary {
+    readonly fullyAutonomous: boolean;
+    readonly automaticStepIds: readonly string[];
+    readonly humanApprovalStepIds: readonly string[];
+    readonly steps: readonly PlanStepAutonomy[];
+}
+export type PlanValidationIssueCode = 'contract_invalid' | 'invalid_schema_version' | 'invalid_plan_version' | 'invalid_parent_version' | 'required_value_missing' | 'duplicate_step_id' | 'duplicate_edge' | 'unknown_edge_step' | 'self_edge' | 'cycle_detected' | 'task_mismatch' | 'contract_version_mismatch' | 'operation_not_allowed' | 'expected_path_missing' | 'path_outside_scope' | 'unknown_requirement' | 'unknown_acceptance_criterion' | 'unknown_required_check' | 'requirement_unplanned' | 'required_check_unplanned';
+export interface PlanValidationIssue {
+    readonly code: PlanValidationIssueCode;
+    readonly path: string;
+    readonly message: string;
+}
+export type PlanValidationResult = {
+    readonly valid: true;
+} | {
+    readonly valid: false;
+    readonly issues: readonly PlanValidationIssue[];
+};
+export type PlanSupersessionIssueCode = 'plan_id_mismatch' | 'task_id_mismatch' | 'version_not_sequential' | 'parent_version_mismatch' | 'contract_version_regressed';
+export interface PlanSupersessionIssue {
+    readonly code: PlanSupersessionIssueCode;
+    readonly message: string;
+}
+export type PlanSupersessionResult = {
+    readonly valid: true;
+} | {
+    readonly valid: false;
+    readonly issues: readonly PlanSupersessionIssue[];
+};
+export type ReplanValidationIssue = PlanValidationIssue | PlanSupersessionIssue | {
+    readonly code: 'invalid_completed_auto_replans';
+    readonly message: string;
+};
+export type ReplanAuthorizationDecision = {
+    readonly valid: true;
+    readonly automatic: true;
+    readonly requiresHumanApproval: false;
+    readonly nextPlanVersion: number;
+} | {
+    readonly valid: true;
+    readonly automatic: false;
+    readonly requiresHumanApproval: true;
+    readonly nextPlanVersion: number;
+    readonly reason: 'auto_authorization_disabled' | 'auto_replan_budget_exhausted';
+} | {
+    readonly valid: false;
+    readonly issues: readonly ReplanValidationIssue[];
+};
+export declare function classifyPlanStepAutonomy(contract: TaskContractV1, step: PlanStepV1): PlanStepAutonomy;
+export declare function summarizePlanAutonomy(contract: TaskContractV1, plan: PlanVersionV1): PlanAutonomySummary;
+export declare function validatePlanVersionV1(plan: PlanVersionV1, contract: TaskContractV1): PlanValidationResult;
+export declare function validatePlanSupersession(previous: PlanVersionV1, next: PlanVersionV1): PlanSupersessionResult;
+export declare function decideReplanAuthorization(contract: TaskContractV1, previous: PlanVersionV1, next: PlanVersionV1, completedAutomaticReplans: number): ReplanAuthorizationDecision;
+export declare function freezePlanVersionV1(plan: PlanVersionV1): PlanVersionV1;
+//# sourceMappingURL=plan-version.d.ts.map

package/dist/project-client.d.ts

@@ -0,0 +1,31 @@
+import type { GovernanceServiceCredential } from './capability-grant.js';
+import { type GovernanceDaemonMetadata } from './daemon-metadata.js';
+import type { GovernanceServiceResponse } from './project-service.js';
+export declare const GOVERNANCE_IPC_DEFAULT_TIMEOUT_MS = 5000;
+export interface GovernanceProjectClientOptions {
+    readonly timeoutMs?: number | undefined;
+}
+export interface ConnectGovernanceProjectClientOptions extends GovernanceProjectClientOptions {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly credential: GovernanceServiceCredential;
+}
+export type ConnectGovernanceProjectClientResult = {
+    readonly connected: true;
+    readonly client: GovernanceProjectClient;
+    readonly metadata: GovernanceDaemonMetadata;
+} | {
+    readonly connected: false;
+    readonly code: 'not_running' | 'endpoint_invalid' | 'project_mismatch' | 'credential_mismatch' | 'authentication_failed' | 'service_rejected';
+    readonly message: string;
+};
+export declare class GovernanceProjectClient {
+    readonly projectRoot: string;
+    readonly endpoint: string;
+    private readonly credential;
+    private readonly timeoutMs;
+    constructor(projectRoot: string, credential: GovernanceServiceCredential, options?: GovernanceProjectClientOptions);
+    request(request: unknown): Promise<GovernanceServiceResponse>;
+}
+export declare function connectGovernanceProjectClient(options: ConnectGovernanceProjectClientOptions): Promise<ConnectGovernanceProjectClientResult>;
+//# sourceMappingURL=project-client.d.ts.map

package/dist/project-daemon.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=project-daemon.d.ts.map