@planu/cli 4.14.1 → 5.1.1

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

@@ -1,6 +1,6 @@
 import type { ToolResult } from './index.js';
 import type { ValidateWorkerCall } from './validate-worker.js';
-import type { DurableJobRecord } from '../storage/runtime-db.js';
+import type { ValidationReceiptIssueInput } from './validation-receipt.js';
 export interface DurableValidationBindings {
     readonly projectId: string;
     readonly specId: string;
@@ -9,6 +9,14 @@ export interface DurableValidationBindings {
     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;
@@ -43,6 +51,76 @@ export interface ValidationPhaseGraphResult {
 }
 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?: () => {
@@ -50,11 +128,31 @@ export interface ValidateJobRecoveryOptions {
             projectId: string;
             workspaceId: string;
         }[];
-        list(projectId: string, workspaceId: string): readonly DurableJobRecord[];
+        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

@@ -1,2 +1,166 @@
-export {};
+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,8 @@ 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';
 }

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

@@ -0,0 +1,34 @@
+import type { Actuals } from './estimation.js';
+/**
+ * Caller-supplied actuals on a `done` transition. Every field is optional:
+ * missing numeric fields are treated as "not measured" and defaulted to 0 by
+ * the done gate; `completedAt`/`notes` default when the whole object is
+ * absent. Any field the caller does supply is always stored verbatim.
+ */
+export type ActualsInput = Partial<Actuals>;
+/** Injectable process runner so tests never shell out to real git. */
+export type EvidenceAutofillExec = (command: string, args: string[], options: {
+    cwd: string;
+}) => Promise<string>;
+export interface AutofillTraceabilityMatrixArgs {
+    projectId: string;
+    specId: string;
+    /** Absolute path to the project working copy; used for `git diff` and file existence checks. */
+    projectPath?: string;
+    /** Raw spec.md content (frontmatter + body) used to derive criteria, scenarios, and `## Files`. */
+    specBody: string;
+    /** Overrides the default `execFile`-based git runner. */
+    exec?: EvidenceAutofillExec;
+    /** Branch to diff against for changed-files detection. Defaults to `main`. */
+    baseBranch?: string;
+}
+export type AutofillTraceabilityMatrixResult = {
+    written: true;
+    path: string;
+    rowCount: number;
+} | {
+    written: false;
+    reason: 'already-exists' | 'no-criteria' | 'write-failed';
+    error?: string;
+};
+//# sourceMappingURL=evidence-autofill.d.ts.map

package/dist/types/evidence-autofill.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=evidence-autofill.js.map

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

@@ -1,4 +1,5 @@
 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;
@@ -41,6 +42,13 @@ export interface TraceabilityMatrixEvidence {
         changedFiles: string[];
         validationEvidence?: string;
         reviewerEvidence?: string;
+        commandEvidence?: {
+            capability: ValidationGateCapability;
+            command: string;
+            scope: string[];
+            relevantPaths?: string[];
+            evidenceKey: string;
+        };
     }[];
 }
 export interface ContractValidationEvidence {
@@ -62,7 +70,7 @@ 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' | 'evidence_provenance_invalid' | '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

@@ -128,6 +128,7 @@ export interface CreateExecutionScopeOptions {
 export interface CancellationScope {
     readonly signal: AbortSignal;
     readonly timeoutMs: number;
+    didDeadlineElapse: () => boolean;
     dispose: () => void;
 }
 export interface BudgetExecution<T> {
@@ -137,6 +138,7 @@ export interface BudgetExecution<T> {
     } | {
         ok: false;
         error: Error;
+        source: 'operation' | 'deadline';
     }>;
     timeoutMs: number;
     dispose: () => void;

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 */
@@ -78,6 +79,46 @@ export interface ValidationReportV1 {
     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

@@ -30,6 +30,7 @@ export * from './privacy.js';
 export * from './events.js';
 export * from './evidence-gates.js';
 export * from './evidence-index.js';
+export * from './evidence-autofill.js';
 export * from './analytics.js';
 export * from './sdd-flow.js';
 export * from './sdd-model-routing.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';
@@ -121,7 +119,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';
@@ -179,7 +177,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';

package/dist/types/index.js

@@ -31,6 +31,7 @@ export * from './privacy.js';
 export * from './events.js';
 export * from './evidence-gates.js';
 export * from './evidence-index.js';
+export * from './evidence-autofill.js';
 export * from './analytics.js';
 export * from './sdd-flow.js';
 export * from './sdd-model-routing.js';
@@ -58,14 +59,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';
@@ -77,7 +76,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';
@@ -176,7 +174,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';

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

@@ -9,12 +9,6 @@ export interface KiroSteeringOptions {
     }[];
     architectureStyle?: string;
 }
-export interface KiroHookDefinition {
-    id: string;
-    event: 'agentSpawn' | 'userPromptSubmit' | 'preToolUse' | 'postToolUse' | 'stop';
-    description: string;
-    script: string;
-}
 export interface KiroSpecFormat {
     id: string;
     title: string;

package/dist/types/network-policy.d.ts

@@ -1,4 +1,4 @@
-export type NetworkPurpose = 'dependency-audit' | 'integration' | 'oauth' | 'registry' | 'telemetry' | 'updates';
+export type NetworkPurpose = 'dependency-audit' | 'feedback' | 'integration' | 'oauth' | 'registry' | 'telemetry' | 'updates';
 export type NetworkRequestPurpose = NetworkPurpose | 'unclassified';
 export interface NetworkConsentReceipt {
     readonly purpose: NetworkPurpose;

package/dist/types/project/lint-scaffolder.d.ts

@@ -1,4 +1,4 @@
-export interface ScaffoldResult {
+export interface LintScaffoldResult {
     eslintCreated: boolean;
     prettierCreated: boolean;
     suggestions: string[];

package/dist/types/runtime-policy.d.ts

@@ -23,11 +23,22 @@ export interface RuntimePolicy {
     };
     validation: {
         defaultDeadlineMs: number;
+        durableLintTimeoutMs: number;
+        complianceCommandTimeoutMs: number;
+        noProgressTimeoutMs: number;
         submissionLockWaitMs: number;
         submissionLockPollMs: number;
         workerLeaseMs: number;
         workerHeartbeatMs: number;
         workerConcurrency: number;
+        heartbeatStartupTimeoutMs: number;
+        heartbeatShutdownTimeoutMs: number;
+        heartbeatDatabaseBusyTimeoutMs: number;
+        freshnessLeaseTtlMs: number;
+        freshnessInvalidationCoalesceMs: number;
+        receiptPublicationDeadlineMs: number;
+        receiptCheckpointLogMaxBytes: number;
+        receiptCheckpointResultMaxBytes: number;
     };
     postCommit: {
         defaultTaskTimeoutMs: number;