@planu/cli 4.13.0 → 5.0.0

package/dist/transports/middleware/with-telemetry.js

@@ -3,6 +3,7 @@ import { appendFile, mkdir } from 'node:fs/promises';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { shouldSkip } from './overrides.js';
+import { TELEMETRY_CONSENT_VERSION } from '../../engine/telemetry/telemetry-store.js';
 /**
  * Project root resolution — tries to get from input args or falls back to cwd.
  */
@@ -27,7 +28,7 @@ export function isTelemetryEnabled(projectRoot) {
         return false;
     }
     if (process.env.PLANU_TELEMETRY === 'on') {
-        return true;
+        return process.env.PLANU_TELEMETRY_CONSENT_VERSION === String(TELEMETRY_CONSENT_VERSION);
     }
     // Read conventions.json for opt-in flag
     try {
@@ -38,7 +39,7 @@ export function isTelemetryEnabled(projectRoot) {
         const raw = readFileSync(conventionsPath, 'utf-8');
         const parsed = JSON.parse(raw);
         const telemetry = parsed.telemetry;
-        return telemetry?.enabled === true;
+        return telemetry?.enabled === true && telemetry.consentVersion === TELEMETRY_CONSENT_VERSION;
     }
     catch {
         return false;

package/dist/transports/session-context.js

@@ -1,5 +1,5 @@
 // session-context.ts — Per-session context using AsyncLocalStorage.
-// Enables multi-tenant hosted mode where each session can have its own license key.
+// Isolates hosted request cancellation and session identity.
 import { AsyncLocalStorage } from 'node:async_hooks';
 const sessionStore = new AsyncLocalStorage();
 /**

package/dist/types/abortable-process.d.ts

@@ -12,6 +12,8 @@ export interface AbortableProcessOptions {
     timeoutMs: number;
     maxBufferBytes: number;
     signal?: AbortSignal;
+    /** Called synchronously after process-group termination has been requested. */
+    onCancellationAcknowledged?: () => void;
 }
 export interface ProjectCommandPlan {
     requestedCommand: string;

package/dist/types/advanced-framework.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical type union (framework names enumerated for type safety)
-// — these literals ARE the canonical contract; no runtime detection logic to migrate.
 // Planu — Advanced framework detection types (SPEC-017b)
 export {};
 //# sourceMappingURL=advanced-framework.js.map

package/dist/types/atomic-upgrade.d.ts

@@ -0,0 +1,71 @@
+import type { SpawnSyncReturns } from 'node:child_process';
+import type { InstallationManifest, InstallationRecord } from '../cli/commands/install.js';
+export type UpgradePhase = 'after-runtime-verification' | 'before-adapter-switch' | 'after-adapter-switch' | 'before-manifest-switch' | 'after-manifest-switch' | 'after-trust-switch';
+export type UpgradeJournalState = 'prepared' | 'switching' | 'trust-switched' | 'committed';
+export interface UpgradeJournal {
+    schemaVersion: 2;
+    state: UpgradeJournalState;
+    manifestPath: string;
+    previousVersion: string;
+    targetVersion: string;
+    originalManifest: string;
+    trustStatePath: string;
+    originalTrustState: string | null;
+    adapters: {
+        configPath: string;
+        original: string;
+    }[];
+    switchedPaths: string[];
+    updatedAt: string;
+}
+export interface ReleaseVerificationReport {
+    version: string;
+    cliPackage: string;
+    nativePackage: string;
+    cliVerified: true;
+    nativeVerified: true;
+    mcpSmokeVerified: true;
+    canaryVerified: true;
+    verifiedAt: string;
+}
+export interface QuarantinedNativeVersion {
+    version: string;
+    failedAt: string;
+    reason: 'verification-failed' | 'activation-failed';
+}
+export interface UpgradeTrustState {
+    schemaVersion: 1;
+    lastKnownGoodVersion: string;
+    lastVerifiedAt: string;
+    quarantined: QuarantinedNativeVersion[];
+}
+export interface UpgradeFaultContext {
+    phase: UpgradePhase;
+    adapter?: InstallationRecord;
+    switchedAdapters: number;
+}
+export interface AtomicUpgradeDependencies {
+    stageAndVerify?: (version: string) => Promise<ReleaseVerificationReport>;
+    writeFile?: (path: string, content: string) => Promise<void>;
+    faultInjector?: (context: UpgradeFaultContext) => void | Promise<void>;
+    now?: () => Date;
+}
+export interface AtomicUpgradeResult {
+    previousVersion: string;
+    version: string;
+    switchedAdapters: number;
+    manifest: InstallationManifest;
+    verification: ReleaseVerificationReport;
+}
+export interface PreparedUpgradeAdapter {
+    record: InstallationRecord;
+    original: string;
+    updated: string;
+}
+export type ReleaseCommandRunner = (command: string, args: readonly string[], options: {
+    encoding: 'utf8';
+    timeout: number;
+    env: NodeJS.ProcessEnv;
+    input?: string;
+}) => SpawnSyncReturns<string>;
+//# sourceMappingURL=atomic-upgrade.d.ts.map

package/dist/types/atomic-upgrade.js

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

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

@@ -66,7 +66,7 @@ export interface StateDriftAlert {
     fix?: string;
 }
 /** SPEC-776: Result of verifyStateFiles() — describes whether planu/ state files are in sync. */
-export interface DriftReport {
+export interface StateFilesDriftReport {
     drifted: boolean;
     alerts: StateDriftAlert[];
 }

package/dist/types/ci.d.ts

@@ -101,9 +101,6 @@ export interface PlanuCIConfig {
         postComment: boolean;
         badge: boolean;
     };
-    license?: {
-        key: string;
-    };
 }
 /** Input for generating a planu-check CI workflow */
 export interface GeneratePlanuCIInput {
@@ -163,6 +160,5 @@ export interface PlanuConfigOptions {
     badge: boolean;
     include?: string[];
     exclude?: string[];
-    licenseKeyRef?: string;
 }
 //# sourceMappingURL=ci.d.ts.map

package/dist/types/ci.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical type union (framework names enumerated for type safety)
-// — these literals ARE the canonical contract; no runtime detection logic to migrate.
 // Planu — CI/CD types (SPEC-066)
 export {};
 //# sourceMappingURL=ci.js.map

package/dist/types/clarification-token.d.ts

@@ -28,7 +28,7 @@ export interface PendingClarificationsFile {
 /**
  * Context passed to checkGate() to determine whether a tool call should proceed.
  */
-export interface GateContext {
+export interface ClarificationGateContext {
     projectId: string;
     toolName: string;
     specId?: string;

package/dist/types/claude-code-runtime.d.ts

@@ -94,13 +94,6 @@ export interface SanctityHookDecision {
     /** Error message displayed when blocking; undefined when allowed. */
     errorMessage?: string;
 }
-/** Options for runPrecompactionDrain(). */
-export interface PrecompactionDrainOptions {
-    /** Whether to skip side-effecting writes (for dry-run tests). */
-    dryRun?: boolean;
-    /** Branch patterns allowed for autopush (default: feat/*, fix/*, chore/*). */
-    autopushBranches?: string[];
-}
 /** Minimal line-emitting source for native hook subscriptions (subset of EventEmitter). */
 export interface LineEmitter {
     on(event: 'line', handler: (line: string) => void): void;
@@ -115,24 +108,4 @@ export interface ExitPlanModeAwaiter {
     /** Manually resolve (used in tests and timeout paths). */
     resolve(): void;
 }
-/** Summary returned by runPrecompactionDrain(). */
-export interface PrecompactionDrainReport {
-    /** Number of learning entries written to MEMORY.md fragments. */
-    learningsFlushed: number;
-    /** Whether session-context.md was written successfully. */
-    sessionContextWritten: boolean;
-    /** Result of the autopush attempt. */
-    autopushResult: PrecompactionAutopushSummary;
-    /** Overall human-readable status line. */
-    humanSummary: string;
-}
-/** Compact autopush summary for the drain report. */
-export type PrecompactionAutopushSummary = {
-    pushed: true;
-    ref: string;
-    commitsPushed: number;
-} | {
-    pushed: false;
-    reason: string;
-};
 //# sourceMappingURL=claude-code-runtime.d.ts.map

package/dist/types/commercial-migration.d.ts

@@ -0,0 +1,17 @@
+export type CommercialCleanupLockRunner = <T>(lockPath: string, operation: (assertFence: () => Promise<void>) => Promise<T>) => Promise<T>;
+export interface RemoveCommercialStateOptions {
+    readonly globalDataPath?: string;
+    readonly legacyGlobalDataPaths?: readonly string[];
+    readonly lockPath?: string;
+    readonly hostConfigPaths?: readonly string[];
+    readonly strict?: boolean;
+    readonly lockRunner?: CommercialCleanupLockRunner;
+    readonly homeDirectory?: string;
+    readonly projectDirectory?: string;
+}
+export interface RemoveCommercialStateResult {
+    readonly removedFiles: number;
+    readonly updatedFiles: number;
+    readonly errors: readonly string[];
+}
+//# sourceMappingURL=commercial-migration.d.ts.map

package/dist/types/commercial-migration.js

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

package/dist/types/common/primitives.d.ts

@@ -10,7 +10,6 @@ export type SpecScope = 'trivial' | 'feature' | 'cross-module' | 'architectural'
 export type SpecTarget = 'frontend' | 'backend' | 'shared' | 'fullstack' | 'infrastructure' | 'database' | 'ios' | 'android';
 export type ExecutionMode = 'local' | 'template' | 'light-llm' | 'full-llm';
 export type SddPhase = 'initializing' | 'analyzing' | 'creating-spec' | 'filtering' | 'reviewing' | 'implementing' | 'validating' | 'documenting' | 'done';
-export type PricingTier = 'free' | 'pro' | 'team' | 'enterprise';
 export interface ToolResult {
     [key: string]: unknown;
     content: {
@@ -24,7 +23,6 @@ export interface NodeError extends Error {
     code?: string;
 }
 export type TemplateMap = Record<string, Record<string, unknown>>;
-export type PricingMap = Record<string, Record<string, number>>;
 /** SPEC-340: Guided next action after a status transition */
 export interface NextAction {
     step: string;

package/dist/types/core-bridge.d.ts

@@ -1,3 +1,5 @@
+import type { SpecAnnotation } from './living-spec/annotations.js';
+export type { SpecAnnotation } from './living-spec/annotations.js';
 export interface FileHash {
     path: string;
     hash: string;
@@ -7,13 +9,78 @@ export interface FileMetadata {
     mtime: number;
     size: number;
 }
-export interface SpecAnnotation {
-    specId: string;
-    criteria: number[];
-    description: string;
-    file: string;
-    line: number;
-    raw: string;
+/** Versioned contract returned by a native runtime before it may execute work. */
+export interface NativeRuntimeHandshake {
+    engineVersion: string;
+    buildId: string;
+    protocolAbi: number;
+    capabilityAbi: number;
+    nodeApiAbi: number;
+    capabilities: string[];
+    storageSchemaMin: number;
+    storageSchemaMax: number;
+    target: string;
+}
+/** Externally generated release metadata stored next to the native artifact. */
+export interface NativeArtifactManifest extends NativeRuntimeHandshake {
+    schemaVersion: 2;
+    cliVersion: string;
+    artifactSha256: string;
+    platform: NodeJS.Platform;
+    arch: string;
+    libc: 'glibc' | 'musl' | null;
+    sbom: {
+        format: 'CycloneDX-1.5';
+        path: string;
+        sha256: string;
+    };
+    provenance: {
+        builder: string;
+        sourceCommit: string;
+        sourceTreeDirty: boolean;
+        sourceDateEpoch: number;
+        rustToolchain: string;
+        zigVersion: string | null;
+    };
+    signature: {
+        algorithm: 'Ed25519';
+        keyId: string;
+        value: string;
+    };
+}
+export interface NativeRuntimeCompatibility {
+    compatible: boolean;
+    reasons: string[];
+    handshake: NativeRuntimeHandshake | null;
+}
+export type NativeFallbackClass = 'optimization' | 'correctness-critical';
+export type NativeFallbackMode = 'typescript-visible-degradation' | 'fail-closed';
+export interface NativeCapabilityPolicy {
+    readonly capability: string;
+    readonly classification: NativeFallbackClass;
+    readonly fallback: NativeFallbackMode;
+    readonly parityContract: string;
+}
+export interface NativeCapabilityDiagnostic {
+    capability: string;
+    state: 'available' | 'degraded' | 'unavailable';
+    fallback: NativeFallbackMode;
+}
+export interface NativeLoadDiagnostic {
+    attempted: string[];
+    errors: string[];
+    loaded?: string;
+    artifactSha256?: string;
+    origin?: 'local' | 'package';
+    compatibility?: NativeRuntimeCompatibility;
+    rejectedOverrides?: string[];
+    capabilities?: NativeCapabilityDiagnostic[];
+    executionScope?: 'isolated-worker-and-keychain-port';
+}
+export interface NativePlatformInfo {
+    platform: NodeJS.Platform;
+    arch: string;
+    libc: 'glibc' | 'musl' | null;
 }
 export interface DriftResult {
     foundKeywords: string[];
@@ -67,7 +134,7 @@ export interface GapsLogChainResultRs {
     totalEntries: number;
     brokenAt: number | null;
 }
-export interface SearchResult {
+export interface NativeVectorSearchResult {
     id: string;
     similarity: number;
 }
@@ -141,6 +208,8 @@ export interface ProjectGraphNeighborRs {
     relation: string;
 }
 export interface PlanuCore {
+    /** Mandatory for runtimes loaded by the versioned bridge. */
+    planuRuntimeHandshake?(): NativeRuntimeHandshake;
     hashProjectPath(projectPath: string): string;
     isSafeProjectId(projectId: string): boolean;
     getProjectDataPath(baseDir: string, project_id: string): string | null;
@@ -158,10 +227,12 @@ export interface PlanuCore {
     fastVerifyGapsChain(filePath: string): GapsLogChainResultRs;
     fastAppendGapEntry(filePath: string, id: string, timestamp: string, specId: string, description: string, severity: string, affectedSpecs: string[]): string;
     fastCosineSimilarity(v1: number[], v2: number[]): number;
-    fastHnswSearchFlat(query: number[], nodes: VectorNode[], topK: number): SearchResult[];
+    fastHnswSearchFlat(query: number[], nodes: VectorNode[], topK: number): NativeVectorSearchResult[];
     fastHmacSign(secret: string, data: string): string;
     fastHmacVerify(secret: string, data: string, signature: string): boolean;
-    startProjectWatcher(rootPath: string, callback: (err: Error | null, event: string) => void): void;
+    macosKeychainSet?(account: string, secret: Buffer): Promise<void>;
+    macosKeychainGet?(account: string): Promise<Buffer | null>;
+    macosKeychainDelete?(account: string): Promise<void>;
     scanProjectGraphSources?(rootPath: string, limits: ResolvedProjectGraphLimitsRs): ProjectGraphSourceFileRs[];
     extractTsRelations?(rootPath: string, paths: string[], limits: ResolvedProjectGraphLimitsRs): TsRelationRs[];
     queryAffectedNodes?(seed: string, edges: GraphEdgeInputRs[], relationFilter: string[], limits: ResolvedProjectGraphLimitsRs): AffectedNodeRs[];

package/dist/types/crash-shield-framework-rules.d.ts

@@ -0,0 +1,24 @@
+import type { CrashRisk } from './safety-scanner.js';
+export type FrameworkRuleActivationMode = 'content' | 'file-and-content' | 'file-or-content';
+export type FrameworkRuleGuardScope = 'file' | 'line' | 'window';
+export interface FrameworkRuleGuard {
+    scope: FrameworkRuleGuardScope;
+    patterns: string[];
+    before?: number;
+    after?: number;
+}
+export interface CrashShieldFrameworkRule {
+    id: string;
+    framework: string;
+    fileExtensions: string[];
+    contentAny: string[];
+    contentAll?: string[];
+    activationMode: FrameworkRuleActivationMode;
+    finding: string;
+    guard?: FrameworkRuleGuard;
+    pattern: string;
+    severity: CrashRisk['severity'];
+    description: string;
+    suggestedFix: string;
+}
+//# sourceMappingURL=crash-shield-framework-rules.d.ts.map

package/dist/types/crash-shield-framework-rules.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=crash-shield-framework-rules.js.map

package/dist/types/dashboard.d.ts

@@ -103,10 +103,7 @@ export interface SpecDetailData {
 }
 /** Usage stats panel data read from data/global/ (SPEC-064) */
 export interface DashboardUsageStats {
-    tier: string;
     callsToday: number;
-    dailyLimit: number | null;
-    trialDaysLeft: number | null;
     isAvailable: boolean;
 }
 /** Raw structure of project.json files read by data-loader */
@@ -135,10 +132,9 @@ export interface RawSpecJson {
 }
 /** Raw structure of usage.json file read by data-loader */
 export interface RawUsageJson {
-    tier?: string;
-    callsToday?: number;
-    dailyLimit?: number | null;
-    trialDaysLeft?: number | null;
+    events?: {
+        timestamp?: string;
+    }[];
 }
 /** A single event representing a change in project data */
 export interface DashboardEvent {

package/dist/types/data-gc.d.ts

@@ -29,6 +29,18 @@ export interface GcRunOptions extends GcScanOptions {
     dataProjectsDir: string;
     /** When true, actually delete candidates; when false (default), dry-run only */
     apply?: boolean;
+    /** Canonical recoverable trash root. Required when apply=true. */
+    trashDir?: string;
+    /** Days until a recoverable trash entry becomes eligible for purge. */
+    trashTtlDays?: number;
+}
+export interface GcTrashMetadata {
+    schemaVersion: 1;
+    originalPath: string;
+    trashedPath: string;
+    trashedAt: string;
+    expiresAt: string;
+    reason: GcReason;
 }
 export interface GcRunResult {
     /** True when no deletions were performed */
@@ -41,6 +53,10 @@ export interface GcRunResult {
     candidateCount: number;
     /** Names of dirs actually deleted (empty in dry-run) */
     deleted: string[];
+    /** Recoverable destination paths for applied candidates. */
+    trashed: string[];
+    /** Expired recoverable entries permanently purged during an applied run. */
+    purgedExpired: string[];
     /** Any errors encountered during deletion */
     errors: string[];
     /** inactiveDays setting used for this run */

package/dist/types/deploy.js

@@ -1,5 +1,3 @@
-// SPEC-597-EXEMPT: canonical type union (framework names enumerated for type safety)
-// — these literals ARE the canonical contract; no runtime detection logic to migrate.
 // types/deploy.ts — SPEC-478: Deploy integration types
 export {};
 //# sourceMappingURL=deploy.js.map

package/dist/types/docs.d.ts

@@ -195,7 +195,6 @@ export interface ToolEntry {
     name: string;
     description: string;
     phase: string;
-    tier: 'free' | 'pro';
 }
 export interface ProjectMetrics {
     totalSpecs: number;

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

@@ -0,0 +1,78 @@
+import type { DurableJobRecord } from '../storage/runtime-db.js';
+import type { NativeWorkerCall, NativeWorkerOperation } from './native-worker.js';
+import type { ValidationArtifactDigests, ValidationFreshnessLease } from './validation-receipt.js';
+export interface DurableJobIdentity {
+    readonly operationId: string;
+    readonly projectId: string;
+    readonly workspaceId?: string;
+}
+export interface WatchJobInput extends DurableJobIdentity {
+    readonly afterCursor?: string;
+    readonly timeoutMs?: number;
+    readonly pollIntervalMs?: number;
+    readonly signal?: AbortSignal;
+}
+export interface DurableJobRuntimeOptions {
+    readonly databasePath?: string;
+}
+export interface NativeDurableJobPayload {
+    readonly kind: 'native-worker';
+    readonly operation: NativeWorkerOperation;
+    readonly payload: Readonly<Record<string, unknown>>;
+    readonly deadlineAt: number;
+    readonly cancellationId?: string;
+}
+export interface ValidateDurableJobPayload {
+    readonly kind: 'validate';
+    readonly schemaVersion: 2;
+    readonly validationRootId: string;
+    readonly input: {
+        readonly specId: string;
+        readonly projectId: string;
+        readonly projectPath?: string;
+    };
+    readonly bindings?: {
+        readonly projectId: string;
+        readonly specId: string;
+        readonly sourceTreeHash: string;
+        readonly specHash: string;
+        readonly policyHash: string;
+        readonly toolchainHash: string;
+    };
+    readonly deadlineAt?: number;
+    readonly artifactDigests?: ValidationArtifactDigests;
+    readonly freshnessLease?: ValidationFreshnessLease;
+    readonly specPath: string;
+}
+export type NativeWorkerRunner = (call: NativeWorkerCall) => Promise<unknown>;
+export interface DurableJobExecutorOptions {
+    readonly runtime: {
+        list(projectId: string, workspaceId?: string): readonly DurableJobRecord[];
+        claim(input: DurableJobIdentity & {
+            readonly workerId: string;
+            readonly leaseMs: number;
+        }): DurableJobRecord | undefined;
+        renew(input: DurableJobIdentity & {
+            readonly workerId: string;
+            readonly leaseMs: number;
+            readonly fencingToken: number;
+        }): boolean;
+        get(input: DurableJobIdentity): DurableJobRecord;
+        complete(input: DurableJobIdentity & {
+            readonly workerId: string;
+            readonly fencingToken: number;
+            readonly result: unknown;
+        }): DurableJobRecord;
+        fail(input: DurableJobIdentity & {
+            readonly workerId: string;
+            readonly fencingToken: number;
+            readonly error: string;
+        }): DurableJobRecord;
+    };
+    readonly workerId: string;
+    readonly leaseMs?: number;
+    readonly heartbeatMs?: number;
+    readonly maxConcurrency?: number;
+    readonly runNative?: NativeWorkerRunner;
+}
+//# sourceMappingURL=durable-job.d.ts.map

package/dist/types/durable-job.js

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