@planu/cli 4.13.0 → 5.0.0

package/dist/types/durable-validation.d.ts

@@ -0,0 +1,158 @@
+import type { ToolResult } from './index.js';
+import type { ValidateWorkerCall } from './validate-worker.js';
+import type { ValidationReceiptIssueInput } from './validation-receipt.js';
+export interface DurableValidationBindings {
+    readonly projectId: string;
+    readonly specId: string;
+    readonly sourceTreeHash: string;
+    readonly specHash: string;
+    readonly policyHash: string;
+    readonly toolchainHash: string;
+}
+export type ValidationWorktreeErrorCode = 'VALIDATION_PAYLOAD_VERSION_UNSUPPORTED' | 'VALIDATION_ROOT_ID_MALFORMED' | 'VALIDATION_ROOT_ID_MISMATCH' | 'VALIDATION_ROOT_BUSY' | 'VALIDATION_ROOT_NOT_GIT_WORKTREE' | 'VALIDATION_COMMON_DIR_MISMATCH' | 'VALIDATION_SPEC_PATH_TRAVERSAL' | 'VALIDATION_SPEC_PATH_SYMLINK' | 'VALIDATION_SPEC_NOT_FOUND' | 'VALIDATION_SPEC_ID_MISMATCH';
+export interface ResolvedValidationWorktree {
+    readonly projectPath: string;
+    readonly gitCommonDir: string;
+    readonly specPath: string;
+    readonly relativeSpecPath: string;
+    readonly validationRootId: string;
+}
+export interface ValidationPhaseProgress {
+    readonly phase: string;
+    readonly command: string;
+    readonly durationMs: number;
+    readonly filesScanned?: number;
+    readonly status: 'running' | 'passed' | 'failed' | 'cancelled';
+    readonly remediation?: string;
+}
+export interface ValidationPhase {
+    readonly id: string;
+    readonly command: {
+        readonly executable: string;
+        readonly args?: readonly string[];
+    };
+    readonly timeoutMs?: number;
+    readonly filesScanned?: number;
+    readonly remediation?: string;
+    readonly onStarted?: () => void;
+    readonly onSettled?: () => void;
+}
+export interface ValidationPhaseResult {
+    readonly id: string;
+    readonly status: 'passed' | 'failed' | 'cancelled';
+    readonly durationMs: number;
+    readonly exitCode: number | null;
+    readonly logDigest: string;
+}
+export interface ValidationPhaseGraphResult {
+    readonly status: 'passed' | 'failed' | 'cancelled';
+    readonly gates: readonly ValidationPhaseResult[];
+    readonly log: string;
+}
+export interface ValidateJobExecutorOptions {
+    readonly runWorker?: (call: ValidateWorkerCall) => Promise<ToolResult>;
+    readonly workerTimingPolicy?: {
+        readonly workerLeaseMs: number;
+        readonly workerHeartbeatMs: number;
+    };
+    readonly receiptCheckpointPolicy?: {
+        readonly logMaxBytes: number;
+        readonly resultMaxBytes: number;
+    };
+    readonly heartbeatFactory?: DurableJobHeartbeatFactory;
+}
+export interface DurableJobHeartbeatIdentity {
+    readonly projectId: string;
+    readonly workspaceId: string;
+    readonly operationId: string;
+    readonly workerId: string;
+    readonly fencingToken: number;
+}
+export interface DurableJobHeartbeatWorkerData extends DurableJobHeartbeatIdentity {
+    readonly kind: 'planu-durable-job-heartbeat';
+    readonly schemaVersion: 1;
+    readonly databasePath: string;
+    readonly leaseMs: number;
+    readonly heartbeatMs: number;
+    readonly databaseBusyTimeoutMs: number;
+}
+export type DurableJobHeartbeatMessage = (DurableJobHeartbeatIdentity & {
+    readonly schemaVersion: 1;
+    readonly type: 'ready';
+}) | (DurableJobHeartbeatIdentity & {
+    readonly schemaVersion: 1;
+    readonly type: 'renewed';
+    readonly sequence: number;
+}) | (DurableJobHeartbeatIdentity & {
+    readonly schemaVersion: 1;
+    readonly type: 'authorityLost';
+    readonly sequence: number;
+    readonly reason: 'cancelled-or-stale' | 'database-failure' | 'worker-failure';
+}) | (DurableJobHeartbeatIdentity & {
+    readonly schemaVersion: 1;
+    readonly type: 'stopped';
+});
+export interface DurableJobHeartbeatController {
+    stop(): Promise<void>;
+}
+export interface DurableJobHeartbeatStartInput extends DurableJobHeartbeatIdentity {
+    readonly databasePath: string;
+    readonly leaseMs: number;
+    readonly heartbeatMs: number;
+    readonly databaseBusyTimeoutMs: number;
+    readonly startupTimeoutMs: number;
+    readonly shutdownTimeoutMs: number;
+    readonly onAuthorityLost: (reason: Error) => void;
+}
+export type DurableJobHeartbeatFactory = (input: DurableJobHeartbeatStartInput) => Promise<DurableJobHeartbeatController>;
+export interface DurableJobHeartbeatWorkerHandle {
+    on(event: 'message', listener: (value: unknown) => void): this;
+    once(event: 'error', listener: (error: Error) => void): this;
+    once(event: 'exit', listener: (code: number) => void): this;
+    postMessage(value: unknown): void;
+    terminate(): Promise<number>;
+    unref(): void;
+    removeAllListeners(): this;
+}
+export interface DurableJobHeartbeatRuntimeOptions {
+    readonly workerFactory?: (url: URL, data: DurableJobHeartbeatWorkerData) => DurableJobHeartbeatWorkerHandle;
+}
+interface ValidationRecoveryJob {
+    readonly payload: unknown;
+    readonly state: string;
+    readonly leaseExpiresAt?: string;
+}
+export interface ValidateJobRecoveryOptions {
+    readonly runtimeFactory?: () => {
+        listRunnableScopes(): readonly {
+            projectId: string;
+            workspaceId: string;
+        }[];
+        list(projectId: string, workspaceId: string): readonly ValidationRecoveryJob[];
+        close(): void;
+    };
+    readonly schedule?: (projectId: string, workspaceId: string) => void;
+    readonly scheduleLater?: (callback: () => void, delayMs: number) => void;
+    readonly now?: () => number;
+}
+export interface ValidationReceiptPendingCheckpoint {
+    readonly kind: 'validation-receipt-pending';
+    readonly schemaVersion: 1;
+    readonly errorCode: 'VALIDATION_RECEIPT_PENDING';
+    readonly recoveryAction: 'restart_job';
+    readonly result: ToolResult;
+    readonly receiptInput: ValidationReceiptIssueInput & {
+        readonly log: string;
+        readonly issuedAt: string;
+    };
+}
+export interface ValidationReceiptCheckpointLimits {
+    readonly logMaxBytes: number;
+    readonly resultMaxBytes: number;
+}
+/** Parse the sole durable authority allowed to resume receipt publication. */
+export declare function parseValidationReceiptPendingCheckpoint(value: unknown, limits: ValidationReceiptCheckpointLimits): ValidationReceiptPendingCheckpoint | undefined;
+/** Detect an attempted receipt authority even when its strict schema is malformed. */
+export declare function isValidationReceiptPendingIntent(value: unknown): boolean;
+export {};
+//# sourceMappingURL=durable-validation.d.ts.map

package/dist/types/durable-validation.js

@@ -0,0 +1,166 @@
+import { redactSensitiveValue } from '../security/redactor.js';
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const PROJECT_ID = /^[a-f0-9]{32}$/u;
+const SPEC_ID = /^SPEC-[1-9]\d*$/u;
+function exactKeys(value, keys) {
+    const actual = Object.keys(value).sort();
+    return (actual.length === keys.length && actual.every((key, index) => key === [...keys].sort()[index]));
+}
+function record(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+function isJsonValue(value) {
+    if (value === null || typeof value === 'string' || typeof value === 'boolean') {
+        return true;
+    }
+    if (typeof value === 'number') {
+        return Number.isFinite(value);
+    }
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    const candidate = record(value);
+    return candidate !== undefined && Object.values(candidate).every(isJsonValue);
+}
+function validToolResult(value) {
+    const candidate = record(value);
+    if (!candidate || !isJsonValue(candidate)) {
+        return false;
+    }
+    if (!Array.isArray(candidate.content) ||
+        !candidate.content.every((item) => {
+            const entry = record(item);
+            return Boolean(entry &&
+                exactKeys(entry, ['text', 'type']) &&
+                entry.type === 'text' &&
+                typeof entry.text === 'string');
+        })) {
+        return false;
+    }
+    if (candidate.isError !== undefined && typeof candidate.isError !== 'boolean') {
+        return false;
+    }
+    return (candidate.structuredContent === undefined ||
+        Boolean(record(candidate.structuredContent) && isJsonValue(candidate.structuredContent)));
+}
+function validBindings(value) {
+    const candidate = record(value);
+    const artifactDigests = record(candidate?.artifactDigests);
+    return Boolean(candidate &&
+        exactKeys(candidate, [
+            'artifactDigests',
+            'policyDigest',
+            'projectId',
+            'sourceDigest',
+            'specDigest',
+            'specId',
+            'toolchainDigest',
+        ]) &&
+        typeof candidate.projectId === 'string' &&
+        PROJECT_ID.test(candidate.projectId) &&
+        typeof candidate.specId === 'string' &&
+        SPEC_ID.test(candidate.specId) &&
+        ['sourceDigest', 'specDigest', 'policyDigest', 'toolchainDigest'].every((key) => typeof candidate[key] === 'string' && DIGEST.test(candidate[key])) &&
+        artifactDigests &&
+        exactKeys(artifactDigests, [
+            'approvedSpec',
+            'contractValidation',
+            'discovery',
+            'taskPlan',
+            'traceability',
+        ]) &&
+        Object.values(artifactDigests).every((digest) => typeof digest === 'string' && DIGEST.test(digest)));
+}
+// eslint-disable-next-line complexity -- the closed persisted authority validates every field without coercion
+function validReceiptInput(value) {
+    const candidate = record(value);
+    if (!candidate ||
+        !exactKeys(candidate, [
+            'bindings',
+            'command',
+            'durationMs',
+            'exitCode',
+            'gates',
+            'issuedAt',
+            'log',
+            'versions',
+        ])) {
+        return false;
+    }
+    const command = record(candidate.command);
+    const versions = record(candidate.versions);
+    const canonicalIssuedAt = typeof candidate.issuedAt === 'string' &&
+        Number.isFinite(Date.parse(candidate.issuedAt)) &&
+        new Date(candidate.issuedAt).toISOString() === candidate.issuedAt;
+    return Boolean(validBindings(candidate.bindings) &&
+        command &&
+        exactKeys(command, ['args', 'cwd', 'executable']) &&
+        command.executable === 'planu' &&
+        command.cwd === '<project>' &&
+        Array.isArray(command.args) &&
+        command.args.length === 2 &&
+        command.args[0] === 'validate' &&
+        typeof command.args[1] === 'string' &&
+        SPEC_ID.test(command.args[1]) &&
+        record(candidate.bindings)?.specId === command.args[1] &&
+        versions &&
+        exactKeys(versions, ['node', 'receiptSchema']) &&
+        typeof versions.node === 'string' &&
+        versions.receiptSchema === '1' &&
+        candidate.exitCode === 0 &&
+        Number.isSafeInteger(candidate.durationMs) &&
+        candidate.durationMs >= 0 &&
+        typeof candidate.log === 'string' &&
+        Array.isArray(candidate.gates) &&
+        candidate.gates.length === 1 &&
+        (() => {
+            const gate = record(candidate.gates[0]);
+            return Boolean(gate &&
+                exactKeys(gate, ['durationMs', 'gate', 'status']) &&
+                gate.gate === 'validation' &&
+                gate.status === 'passed' &&
+                Number.isSafeInteger(gate.durationMs) &&
+                gate.durationMs >= 0);
+        })() &&
+        canonicalIssuedAt);
+}
+/** Parse the sole durable authority allowed to resume receipt publication. */
+// eslint-disable-next-line complexity -- persisted authority checks shape, privacy, and both policy byte bounds without coercion
+export function parseValidationReceiptPendingCheckpoint(value, limits) {
+    const candidate = record(value);
+    const redacted = redactSensitiveValue(value);
+    if (!Number.isSafeInteger(limits.logMaxBytes) ||
+        limits.logMaxBytes <= 0 ||
+        !Number.isSafeInteger(limits.resultMaxBytes) ||
+        limits.resultMaxBytes <= 0 ||
+        limits.logMaxBytes > limits.resultMaxBytes ||
+        !candidate ||
+        !exactKeys(candidate, [
+            'errorCode',
+            'kind',
+            'receiptInput',
+            'recoveryAction',
+            'result',
+            'schemaVersion',
+        ]) ||
+        candidate.kind !== 'validation-receipt-pending' ||
+        candidate.schemaVersion !== 1 ||
+        candidate.errorCode !== 'VALIDATION_RECEIPT_PENDING' ||
+        candidate.recoveryAction !== 'restart_job' ||
+        !validToolResult(candidate.result) ||
+        !validReceiptInput(candidate.receiptInput) ||
+        Buffer.byteLength(JSON.stringify(candidate.result), 'utf8') > limits.resultMaxBytes ||
+        Buffer.byteLength(candidate.receiptInput.log, 'utf8') >
+            limits.logMaxBytes ||
+        JSON.stringify(redacted) !== JSON.stringify(candidate)) {
+        return undefined;
+    }
+    return candidate;
+}
+/** Detect an attempted receipt authority even when its strict schema is malformed. */
+export function isValidationReceiptPendingIntent(value) {
+    return record(value)?.kind === 'validation-receipt-pending';
+}
+//# sourceMappingURL=durable-validation.js.map

package/dist/types/errors/structured-error.d.ts

@@ -1,6 +1,6 @@
 import type { ToolResult } from '../index.js';
 export type ToolHandler = (args: Record<string, unknown>, extra?: unknown) => Promise<ToolResult>;
-export interface NextAction {
+export interface StructuredErrorNextAction {
     tool: string;
     args: Record<string, unknown>;
     rationale?: string;
@@ -9,7 +9,7 @@ export interface StructuredError {
     ok: false;
     what: string;
     why: string;
-    nextAction: NextAction;
+    nextAction: StructuredErrorNextAction;
     errorCode?: string;
     citations?: string[];
 }
@@ -21,7 +21,7 @@ export interface ErrorRecoveryRule {
     };
     what: string;
     why?: string;
-    nextAction: NextAction;
+    nextAction: StructuredErrorNextAction;
 }
 export interface WrapCtx {
     toolName: string;

package/dist/types/estimation.d.ts

@@ -58,6 +58,10 @@ export interface ValidateInput {
     specId: string;
     projectId?: string;
     projectPath?: string;
+    /** Internal executor-owned portable spec path after worktree verification. */
+    specPath?: string;
+    /** Durable submission is the only public MCP execution mode. */
+    mode?: 'submit';
 }
 export interface EstimateResult {
     difficulty: Difficulty;

package/dist/types/evidence-gates.d.ts

@@ -1,6 +1,9 @@
+import type { ValidationArtifactProvenance, ValidationReceipt } from './validation-receipt.js';
+import type { ValidationGateCapability } from './validation-evidence.js';
 export type EvidenceGateTransition = 'approved' | 'implementing' | 'done';
 export interface DiscoveryEvidence {
     version: 1;
+    provenance?: ValidationArtifactProvenance;
     rules: string[];
     examples: {
         rule: string;
@@ -19,6 +22,7 @@ export interface DiscoveryEvidence {
 }
 export interface TaskPlanEvidence {
     version: 1;
+    provenance?: ValidationArtifactProvenance;
     tasks: {
         id: string;
         title: string;
@@ -28,6 +32,7 @@ export interface TaskPlanEvidence {
 }
 export interface TraceabilityMatrixEvidence {
     version: 1;
+    provenance?: ValidationArtifactProvenance;
     rows: {
         acceptanceCriterion: string;
         scenario?: string;
@@ -37,10 +42,18 @@ export interface TraceabilityMatrixEvidence {
         changedFiles: string[];
         validationEvidence?: string;
         reviewerEvidence?: string;
+        commandEvidence?: {
+            capability: ValidationGateCapability;
+            command: string;
+            scope: string[];
+            relevantPaths?: string[];
+            evidenceKey: string;
+        };
     }[];
 }
 export interface ContractValidationEvidence {
     version: 1;
+    provenance?: ValidationArtifactProvenance;
     kind: 'api' | 'graphql' | 'event' | 'ui' | 'mcp';
     passed: boolean;
     reportPath?: string;
@@ -53,8 +66,11 @@ export interface EvidenceArtifacts {
     contractValidations: ContractValidationEvidence[];
     invalidArtifacts: string[];
 }
+export interface EvidenceReceiptContext {
+    receipt: ValidationReceipt;
+}
 export interface EvidenceGateIssue {
-    code: 'discovery_missing' | 'discovery_unresolved_questions' | 'task_plan_missing' | 'task_plan_uncovered_criteria' | 'traceability_missing' | 'traceability_uncovered_criteria' | 'traceability_incomplete_rows' | 'contract_validation_missing' | 'contract_validation_failed' | 'done_drift_uncovered_criteria' | 'done_drift_stale_evidence' | 'done_drift_unapproved_scope' | 'evidence_artifact_invalid';
+    code: 'discovery_missing' | 'discovery_unresolved_questions' | 'task_plan_missing' | 'task_plan_uncovered_criteria' | 'traceability_missing' | 'traceability_uncovered_criteria' | 'traceability_incomplete_rows' | 'contract_validation_missing' | 'contract_validation_failed' | 'evidence_provenance_invalid' | 'done_drift_uncovered_criteria' | 'done_drift_stale_evidence' | 'done_drift_unapproved_scope' | 'evidence_artifact_invalid' | 'SUPERSEDED_RECONCILIATION_EVIDENCE';
     message: string;
 }
 export interface EvidenceGateResult {

package/dist/types/execution.d.ts

@@ -98,4 +98,49 @@ export interface ClaudeCommandOptions {
     allowedTools?: string[];
     nonInteractive?: boolean;
 }
+export type RequestExecutionPhase = 'running' | 'committed' | 'acknowledged' | 'cancelled';
+export interface RequestExecutionState {
+    phase: RequestExecutionPhase;
+}
+export interface RequestExecutionContext {
+    readonly requestId: string;
+    readonly idempotencyKey?: string;
+    readonly deadlineAt: number;
+    readonly signal: AbortSignal;
+    readonly phase: RequestExecutionPhase;
+    remainingMs(): number;
+    assertCanCommit(): void;
+    markCommitted(): void;
+}
+export interface RequestExecutionScope {
+    readonly context: RequestExecutionContext;
+    run<T>(fn: () => T): T;
+    cancel(reason?: unknown): void;
+    acknowledge(): void;
+    dispose: () => void;
+}
+export interface CreateExecutionScopeOptions {
+    deadlineAt: number;
+    upstreamSignal?: AbortSignal;
+    requestId?: string;
+    idempotencyKey?: string;
+}
+export interface CancellationScope {
+    readonly signal: AbortSignal;
+    readonly timeoutMs: number;
+    didDeadlineElapse: () => boolean;
+    dispose: () => void;
+}
+export interface BudgetExecution<T> {
+    result: Promise<{
+        ok: true;
+        value: T;
+    } | {
+        ok: false;
+        error: Error;
+        source: 'operation' | 'deadline';
+    }>;
+    timeoutMs: number;
+    dispose: () => void;
+}
 //# sourceMappingURL=execution.d.ts.map

package/dist/types/gemini-integration.d.ts

@@ -4,17 +4,6 @@ export interface GeminiDetectionResult {
     configPath?: string;
     hasGeminiMd: boolean;
 }
-export type GeminiHookEvent = 'SessionStart' | 'SessionEnd' | 'BeforeAgent' | 'AfterAgent' | 'BeforeModel' | 'AfterModel' | 'BeforeToolSelection' | 'BeforeTool' | 'AfterTool' | 'PreCompress' | 'Notification';
-export interface GeminiHook {
-    event: GeminiHookEvent;
-    command: string;
-    timeout?: number;
-    matcher?: string;
-}
-export interface GeminiSettings {
-    hooks: GeminiHook[];
-    theme?: string;
-}
 export interface GeminiPolicy {
     name: string;
     description: string;

package/dist/types/handoff-artifacts.d.ts

@@ -1,3 +1,4 @@
+import type { Spec } from './spec/core.js';
 /** Artifact kinds produced/consumed by each role transition */
 export type ArtifactKind = 'intake' | 'spec.lock' | 'review_feedback' | 'implementation-report' | 'validation-report';
 /** Triagier → Elicitor: describes the intent to be elaborated */
@@ -75,7 +76,49 @@ export interface ValidationReportV1 {
     minimalityReport?: MinimalImplementationReport;
     score?: number;
     completedAt: string;
+    receiptId?: string;
+    receiptKey?: string;
 }
+export type ReconciliationReceiptState = 'prepared' | 'committed' | 'aborted';
+/** Mutable, atomically replaced recovery record for a reconciliation transaction. */
+export interface ReconciliationReceiptV1 {
+    schema_version: '1.0.0';
+    projectId: string;
+    specId: string;
+    requestId: string;
+    sourceImplementingTransitionId: string;
+    sourceUpdatedAt: string;
+    bindingDigest: string;
+    reasonDigest: string;
+    implementationReviewDigest: string;
+    supersededArtifacts: {
+        artifactId: string;
+        sha256?: string;
+    }[];
+    state: ReconciliationReceiptState;
+    stateHistory: {
+        state: ReconciliationReceiptState;
+        at: string;
+        reason?: string;
+    }[];
+    preparedAt: string;
+    committedAt?: string;
+    abortedAt?: string;
+    committedTransitionId?: string;
+    transitionId?: string;
+    phase?: 'prepared' | 'status-committed' | 'spec-synced' | 'audit-appended';
+    auditPending?: boolean;
+}
+/** Injectable receipt persistence boundary used only for reconciliation crash tests. */
+export interface ReconciliationIo {
+    writeReceipt?: (path: string, receipt: ReconciliationReceiptV1) => Promise<void>;
+}
+/** Portable spec synchronization injected by the tool boundary into lifecycle reconciliation. */
+export type ReconciliationSpecSync = (spec: Spec, currentStatus: 'implementing' | 'review', newStatus: 'implementing' | 'review', projectPath?: string) => Promise<{
+    warning?: {
+        reason: string;
+    };
+}>;
 export interface ArtifactPayloadMap {
     intake: IntakeV1;
     'spec.lock': SpecLockV1;

package/dist/types/hooks-advanced.d.ts

@@ -1,16 +1,3 @@
-export type ClaudeCodeEventType = 'Stop' | 'PreCompact' | 'UserPromptSubmit' | 'Notification' | 'WorktreeCreate' | 'WorktreeRemove';
-export interface HookScript {
-    eventType: ClaudeCodeEventType;
-    scriptContent: string;
-    description: string;
-}
-export interface FullSpectrumHookConfig {
-    stopHook: boolean;
-    preCompactHook: boolean;
-    userPromptSubmitHook: boolean;
-    notificationHook: boolean;
-    worktreeHooks: boolean;
-}
 export interface CustomCommand {
     name: string;
     description: string;

package/dist/types/impact-detection.d.ts

@@ -10,10 +10,10 @@ export interface ImpactDetectionResult {
 }
 export interface TestBreakHit {
     testPath: string;
-    matchedPattern: 'tool-count' | 'snapshot' | 'license-plans-sync' | 'streams-anchor';
+    matchedPattern: 'tool-count' | 'snapshot' | 'tool-registry-sync' | 'streams-anchor';
     linePreview: string;
 }
-export type AnticipatedBreakPattern = 'tool-count' | 'snapshot' | 'license-plans-sync' | 'streams-anchor' | 'other';
+export type AnticipatedBreakPattern = 'tool-count' | 'snapshot' | 'tool-registry-sync' | 'streams-anchor' | 'other';
 export interface AnticipatedBreak {
     testPath: string;
     pattern: AnticipatedBreakPattern;

package/dist/types/index.d.ts

@@ -22,6 +22,7 @@ export * from './docs.js';
 export * from './git.js';
 export * from './orchestration/index.js';
 export * from './security.js';
+export * from './validation-receipt.js';
 export * from './lifecycle.js';
 export * from './migration/index.js';
 export * from './migration-advanced.js';
@@ -56,14 +57,12 @@ export * from './actionable-spec-metrics.js';
 export * from './actuals.js';
 export * from './risk.js';
 export * from './context-budget.js';
-export * from './licensing.js';
 export * from './usage.js';
-export * from './changelog.js';
+export * from './commercial-migration.js';
 export * from './coverage.js';
 export * from './ai-cost.js';
 export * from './hooks.js';
 export * from './hook-status-update.js';
-export * from './webhook.js';
 export * from './ci.js';
 export * from './spec-templates.js';
 export * from './spec-generator.js';
@@ -75,7 +74,6 @@ export * from './code-transforms.js';
 export * from './ecosystem.js';
 export * from './model-routing.js';
 export * from './vector-store.js';
-export * from './session.js';
 export * from './ide.js';
 export * from './delete.js';
 export * from './runtime-security.js';
@@ -120,7 +118,7 @@ export * from './error-telemetry.js';
 export * from './audit-trail.js';
 export * from './elicitation.js';
 export * from './well-known.js';
-export type { ValidationSource, ValidationError, ValidationWarning, ValidationResult as SpecValidationResult, ValidateSpecFormatOptions, } from './validation.js';
+export type { ValidationSource, ValidationError, ValidationWarning, SpecValidationResult, ValidateSpecFormatOptions, } from './validation.js';
 export * from './observability.js';
 export * from './resources.js';
 export * from './discovery.js';
@@ -178,7 +176,6 @@ export * from './property-testing.js';
 export * from './agent-ready.js';
 export * from './compliance.js';
 export * from './version-resolution.js';
-export * from './product-intelligence.js';
 export * from './agent-orchestration.js';
 export * from './living-specs.js';
 export * from './filesystem-hooks.js';
@@ -295,4 +292,5 @@ export * from './opencode.js';
 export * from './host-tool-filter.js';
 export * from './reconcile.js';
 export * from './release-pipeline.js';
+export * from './network-policy.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/index.js

@@ -23,6 +23,7 @@ export * from './docs.js';
 export * from './git.js';
 export * from './orchestration/index.js';
 export * from './security.js';
+export * from './validation-receipt.js';
 export * from './lifecycle.js';
 export * from './migration/index.js';
 export * from './migration-advanced.js';
@@ -57,14 +58,12 @@ export * from './actionable-spec-metrics.js';
 export * from './actuals.js';
 export * from './risk.js';
 export * from './context-budget.js';
-export * from './licensing.js';
 export * from './usage.js';
-export * from './changelog.js';
+export * from './commercial-migration.js';
 export * from './coverage.js';
 export * from './ai-cost.js';
 export * from './hooks.js';
 export * from './hook-status-update.js';
-export * from './webhook.js';
 export * from './ci.js';
 export * from './spec-templates.js';
 export * from './spec-generator.js';
@@ -76,7 +75,6 @@ export * from './code-transforms.js';
 export * from './ecosystem.js';
 export * from './model-routing.js';
 export * from './vector-store.js';
-export * from './session.js';
 export * from './ide.js';
 export * from './delete.js';
 export * from './runtime-security.js';
@@ -175,7 +173,6 @@ export * from './property-testing.js';
 export * from './agent-ready.js';
 export * from './compliance.js';
 export * from './version-resolution.js';
-export * from './product-intelligence.js';
 export * from './agent-orchestration.js';
 export * from './living-specs.js';
 export * from './filesystem-hooks.js';
@@ -306,4 +303,5 @@ export * from './host-tool-filter.js';
 export * from './reconcile.js';
 // SPEC-1012: Release spec closer types
 export * from './release-pipeline.js';
+export * from './network-policy.js';
 //# sourceMappingURL=index.js.map