@planu/cli 4.14.1 → 5.0.0

package/dist/tools/usage-report.js

@@ -3,28 +3,13 @@
 import { usageStore } from '../storage/index.js';
 import { filterEventsByPeriod } from '../engine/usage-tracker/core.js';
 import { calculateUsageStats, formatStatsAsMarkdown } from '../engine/usage-tracker/stats.js';
-import { calculateDaysSinceFirstRun, isTrialActive } from '../engine/usage-tracker/trial.js';
-import { getCurrentTier } from './license-gate.js';
 import { compactJson, compactResult } from './output-formatter.js';
 export async function handleUsageReport(args) {
     const format = args.format ?? 'markdown';
-    const tier = await getCurrentTier();
-    // Gather data from storage
     const usageLog = await usageStore.getUsageLog();
-    const trialState = await usageStore.ensureTrialState();
-    const today = new Date().toISOString().slice(0, 10);
-    const todayCount = await usageStore.getDailyCallCount(today);
-    // Compute context values
-    const daysSinceFirstRun = calculateDaysSinceFirstRun(trialState.firstRunAt);
-    const trialActive = isTrialActive(trialState.firstRunAt);
-    let remainingDailyCalls = -1;
-    if (tier === 'free') {
-        const dailyLimit = trialActive ? 50 : 30;
-        remainingDailyCalls = Math.max(0, dailyLimit - todayCount);
-    }
     // Full report uses all events
     const allEvents = filterEventsByPeriod(usageLog.events, 'all');
-    const stats = calculateUsageStats(allEvents, 0, 0, tier, daysSinceFirstRun, trialActive, remainingDailyCalls);
+    const stats = calculateUsageStats(allEvents, 0, 0);
     if (format === 'json') {
         return compactResult(compactJson(stats));
     }

package/dist/tools/usage-stats.js

@@ -3,32 +3,15 @@
 import { usageStore } from '../storage/index.js';
 import { filterEventsByPeriod } from '../engine/usage-tracker/core.js';
 import { calculateUsageStats, formatStatsAsMarkdown } from '../engine/usage-tracker/stats.js';
-import { calculateDaysSinceFirstRun, isTrialActive } from '../engine/usage-tracker/trial.js';
-import { getCurrentTier } from './license-gate.js';
 import { addNextSteps } from './response-helpers.js';
 import { t } from '../i18n/index.js';
 export async function handleUsageStats(args) {
     const period = args.period ?? '30d';
-    const tier = await getCurrentTier();
-    // Gather data from storage
     const usageLog = await usageStore.getUsageLog();
-    const trialState = await usageStore.ensureTrialState();
-    const today = new Date().toISOString().slice(0, 10);
-    const todayCount = await usageStore.getDailyCallCount(today);
-    // Compute context values
-    const daysSinceFirstRun = calculateDaysSinceFirstRun(trialState.firstRunAt);
-    const trialActive = isTrialActive(trialState.firstRunAt);
-    // Remaining daily calls: only relevant for Starter tier
-    let remainingDailyCalls = -1;
-    if (tier === 'free') {
-        const dailyLimit = trialActive ? 50 : 30;
-        remainingDailyCalls = Math.max(0, dailyLimit - todayCount);
-    }
     // Filter events by period and calculate stats
     const filteredEvents = filterEventsByPeriod(usageLog.events, period);
     const stats = calculateUsageStats(filteredEvents, 0, // activeSpecs — placeholder, no cross-layer access to spec store
-    0, // activeProjects — placeholder
-    tier, daysSinceFirstRun, trialActive, remainingDailyCalls);
+    0);
     const markdown = formatStatsAsMarkdown(stats);
     const header = t('tools.response.statsTitle');
     const withHeader = `${header}\n\n${markdown}`;

package/dist/tools/usage-tracking.d.ts

@@ -0,0 +1,4 @@
+import type { ToolResult } from '../types/index.js';
+/** Record local tool health without entitlement, tier, trial, or quota behavior. */
+export declare function withUsageTracking<T>(toolName: string, handler: (args: T, extra?: unknown) => Promise<ToolResult>): (args: T, extra?: unknown) => Promise<ToolResult>;
+//# sourceMappingURL=usage-tracking.d.ts.map

package/dist/tools/usage-tracking.js

@@ -0,0 +1,20 @@
+import { recordUsageEvent } from '../engine/usage-tracker/index.js';
+import * as usageStore from '../storage/usage-store.js';
+import { reportClassifiedDegradation } from '../errors/classified-degradation.js';
+/** Record local tool health without entitlement, tier, trial, or quota behavior. */
+export function withUsageTracking(toolName, handler) {
+    return async (args, extra) => {
+        const rawResult = (await handler(args, extra));
+        const result = rawResult ?? {
+            content: [{ type: 'text', text: 'Internal error: tool handler returned no result' }],
+            isError: true,
+        };
+        void usageStore
+            .appendUsageEvent(recordUsageEvent(toolName, result.isError !== true))
+            .catch((error) => {
+            reportClassifiedDegradation('USAGE_EVENT_WRITE_FAILED', error);
+        });
+        return result;
+    };
+}
+//# sourceMappingURL=usage-tracking.js.map

package/dist/tools/validate-lint.d.ts

@@ -2,6 +2,7 @@ import type { LintCheckResult } from '../types/index.js';
 interface LintCheckContext {
     projectId?: string;
     specId?: string;
+    maximumTimeoutMs?: number;
 }
 export declare function runLintCheck(projectPath: string, lintCommand: string | null, context?: LintCheckContext): Promise<LintCheckResult>;
 export {};

package/dist/tools/validate-lint.js

@@ -80,7 +80,7 @@ export async function runLintCheck(projectPath, lintCommand, context = {}) {
             };
         }
     }
-    const timeoutMs = lintCheckTimeoutMs();
+    const timeoutMs = Math.min(lintCheckTimeoutMs(), context.maximumTimeoutMs ?? Number.MAX_SAFE_INTEGER);
     try {
         const startedAt = Date.now();
         const processResult = await runProjectCommandPlan(plan, projectPath, timeoutMs, getToolExecutionSignal());

package/dist/tools/validate.d.ts

@@ -1,9 +1,10 @@
 import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { validateContractCompliance } from '../engine/test-scaffold-generator.js';
 import type { ValidateInput, ToolResult, ContractSpec, ContractValidation } from '../types/index.js';
+import type { ValidateWorkerProgress } from '../types/validate-worker.js';
 export { validateContractCompliance };
 export type { ContractSpec, ContractValidation };
 /** Public MCP boundary: persist and acknowledge validation work without running it inline. */
 export declare function handleValidate(args: ValidateInput): Promise<ToolResult>;
-export declare function executeValidate(args: ValidateInput, server?: McpServer): Promise<ToolResult>;
+export declare function executeValidate(args: ValidateInput, server?: McpServer, onProgress?: (progress: ValidateWorkerProgress) => void): Promise<ToolResult>;
 //# sourceMappingURL=validate.d.ts.map

package/dist/tools/validate.js

@@ -58,6 +58,7 @@ import { compactObj } from '../engine/compact-obj.js';
 import { resolveProjectId, missingProjectIdError } from './resolve-project-id.js';
 import { specStore, knowledgeStore } from '../storage/index.js';
 import { validateSpec, generateDoR, generateDoD } from '../engine/validator.js';
+import { isBlockingQualitySeverity } from '../engine/validator/dor-dod.js';
 import { calcQualityScore } from '../engine/auditor-scoring.js';
 import { dispatchFeedbackEvent } from './learn.js';
 import { t, ti } from '../i18n/index.js';
@@ -74,14 +75,45 @@ import { runLintCheck } from './validate-lint.js';
 import { checkPlanuUncommittedChanges, runAssuranceGates } from './validate-assurance.js';
 import { applyValidateStructuredCompat } from './validate-structured-compat.js';
 import { getToolExecutionSignal } from './safe-handler.js';
-import { durableJobCursor, DurableJobRuntime } from '../engine/execution/job-runtime.js';
+import { DurableJobRuntime, publicJobCursor } from '../engine/execution/job-runtime.js';
 import { scheduleValidateJobExecution } from '../engine/execution/validate-job-executor.js';
 import { createPendingValidationSubmission } from '../engine/validation/durable-validation.js';
 import { PROJECT_ID as CANONICAL_PROJECT_ID } from '../engine/validation/validation-receipt-codec.js';
 import { acquireLock, releaseLock } from '../engine/safety/cross-process-lock.js';
 import { getRuntimePolicy } from '../engine/runtime-policy.js';
+import { resolveValidationWorktree, ValidationWorktreeError, } from '../engine/validation/validation-worktree.js';
 // Re-export for external use (SPEC-018)
 export { validateContractCompliance };
+const VALIDATION_GATE_TOTAL = 8;
+function createValidationStageRunner(onProgress) {
+    const startedAt = Date.now();
+    let completedGates = 0;
+    return async (phase, command, work) => {
+        const emit = (status) => {
+            onProgress?.({
+                phase,
+                command,
+                durationMs: Date.now() - startedAt,
+                completedGates,
+                totalGates: VALIDATION_GATE_TOTAL,
+                lastProgressAt: new Date().toISOString(),
+                status,
+            });
+        };
+        emit('running');
+        try {
+            const result = await work();
+            completedGates += 1;
+            emit('passed');
+            return result;
+        }
+        catch (error) {
+            completedGates += 1;
+            emit('failed');
+            throw error;
+        }
+    };
+}
 /** Public MCP boundary: persist and acknowledge validation work without running it inline. */
 export async function handleValidate(args) {
     const projectId = resolveProjectId(args);
@@ -130,7 +162,18 @@ export async function handleValidate(args) {
             structuredContent: { error: 'project_not_found', code: 404, context: { projectId } },
         };
     }
-    const projectPath = args.projectPath ?? knowledge.projectPath;
+    let validationWorktree;
+    try {
+        validationWorktree = await resolveValidationWorktree({
+            requestedProjectPath: args.projectPath ?? knowledge.projectPath,
+            canonicalProjectPath: knowledge.projectPath,
+            canonicalSpecPath: spec.specPath,
+            specId: args.specId,
+        });
+    }
+    catch (error) {
+        return validationWorktreeErrorResult(error, args.specId);
+    }
     const submissionLock = await acquireValidationSubmissionLock(projectId, args.specId);
     try {
         const env_1 = { stack: [], error: void 0, hasError: false };
@@ -143,21 +186,30 @@ export async function handleValidate(args) {
                     payload.input?.specId === args.specId);
             });
             if (active) {
+                const activePayload = active.payload;
+                if (activePayload?.validationRootId !== validationWorktree.validationRootId) {
+                    return validationWorktreeErrorResult(new ValidationWorktreeError('VALIDATION_ROOT_BUSY', args.specId), args.specId);
+                }
                 if (active.state === 'accepted' || active.state === 'checkpointed') {
                     scheduleValidateJobExecution(projectId, active.workspaceId);
                 }
-                return validationAcceptedResult(active, projectId);
+                return validationAcceptedResult(active, projectId, runtime);
             }
             const job = createPendingValidationSubmission({
                 runtime,
                 canonicalProjectId: projectId,
-                spec: { id: args.specId, projectPath, specPath: spec.specPath },
+                spec: {
+                    id: args.specId,
+                    projectPath: validationWorktree.projectPath,
+                    specPath: validationWorktree.relativeSpecPath,
+                    validationRootId: validationWorktree.validationRootId,
+                },
                 deadlineAt: Date.now() + getRuntimePolicy().validation.defaultDeadlineMs,
             });
             if (job.state === 'accepted' || job.state === 'checkpointed') {
                 scheduleValidateJobExecution(projectId, job.workspaceId);
             }
-            return validationAcceptedResult(job, projectId);
+            return validationAcceptedResult(job, projectId, runtime);
         }
         catch (e_1) {
             env_1.error = e_1;
@@ -171,6 +223,23 @@ export async function handleValidate(args) {
         await releaseLock(submissionLock);
     }
 }
+function validationWorktreeErrorResult(error, specId) {
+    const failure = error instanceof ValidationWorktreeError
+        ? error
+        : new ValidationWorktreeError('VALIDATION_ROOT_NOT_GIT_WORKTREE', specId);
+    return {
+        content: [{ type: 'text', text: failure.message }],
+        isError: true,
+        structuredContent: {
+            error: 'validation_worktree_rejected',
+            code: failure.code,
+            context: {
+                specId: failure.specId,
+                ...(failure.relativeSpecPath ? { path: failure.relativeSpecPath } : {}),
+            },
+        },
+    };
+}
 async function acquireValidationSubmissionLock(projectId, specId) {
     const policy = getRuntimePolicy().validation;
     const deadlineAt = Date.now() + policy.submissionLockWaitMs;
@@ -188,7 +257,8 @@ async function acquireValidationSubmissionLock(projectId, specId) {
     }
     throw new Error('[Planu] Timed out waiting for the validation submission lock');
 }
-function validationAcceptedResult(job, projectId) {
+function validationAcceptedResult(job, projectId, runtime) {
+    const observation = runtime.observe(job);
     const accepted = {
         schemaVersion: 1,
         operationId: job.id,
@@ -196,7 +266,8 @@ function validationAcceptedResult(job, projectId) {
         workspaceId: job.workspaceId,
         state: job.state,
         submittedAt: job.createdAt,
-        cursor: durableJobCursor(job),
+        cursor: publicJobCursor(observation),
+        queue: observation.queue,
         terminalStates: ['completed', 'failed', 'cancelled', 'dead-letter'],
         resultSchema: 'validate-completion/v1',
         observation: {
@@ -213,7 +284,7 @@ function validationAcceptedResult(job, projectId) {
 }
 // SPEC-595: server? param enables elicitation for direct internal/test execution.
 // eslint-disable-next-line max-lines-per-function -- validate orchestrates many existing gates in one handler.
-export async function executeValidate(args, server) {
+export async function executeValidate(args, server, onProgress) {
     const { specId } = args;
     const projectId = resolveProjectId(args);
     if (!projectId) {
@@ -245,49 +316,56 @@ export async function executeValidate(args, server) {
             },
         };
     }
-    const projectPath = knowledge.projectPath;
+    const projectPath = args.projectPath ?? knowledge.projectPath;
+    const executionSpec = args.specPath ? { ...spec, specPath: args.specPath } : spec;
+    const runStage = createValidationStageRunner(onProgress);
     // SPEC-1017: fail closed when planu/ contains non-canonical artifacts.
-    const strictLayoutError = await validateStrictLayoutOrError({
+    const strictLayoutError = await runStage('layout', 'validate strict layout', () => validateStrictLayoutOrError({
         projectPath,
         specId,
-        specPath: spec.specPath,
-    });
+        specPath: executionSpec.specPath,
+    }));
     if (strictLayoutError !== null) {
         return strictLayoutError;
     }
-    const result = await validateSpec(spec, projectPath);
-    const graphCoverage = await buildGraphCoverageReport({ projectId, projectPath, specId });
-    const dor = generateDoR(spec);
-    const dod = await generateDoD(spec, result, undefined, projectPath);
+    const result = await runStage('spec-scan', 'validate spec implementation', () => validateSpec(executionSpec, projectPath));
+    const graphCoverage = await runStage('graph', 'validate graph coverage', () => buildGraphCoverageReport({ projectId, projectPath, specId }));
+    const { dor, dod } = await runStage('definitions', 'validate ready and done definitions', async () => ({
+        dor: generateDoR(executionSpec),
+        dod: await generateDoD(executionSpec, result, undefined, projectPath),
+    }));
     const implementationQualityScore = calcQualityScore(result.qualityIssues);
     const auditedFiles = [...new Set(result.qualityIssues.map((i) => i.file))];
-    const { conventionViolations, regressionDetected } = await scanProjectConventions(projectId, projectPath);
-    const lintCheck = await runLintCheck(projectPath, knowledge.lintCommand ?? null, {
+    const { conventionViolations, regressionDetected } = await runStage('conventions', 'validate project conventions', () => scanProjectConventions(projectId, projectPath));
+    const lintCheck = await runStage('lint', knowledge.lintCommand ?? 'pnpm lint', () => runLintCheck(projectPath, knowledge.lintCommand ?? null, {
         projectId,
         specId,
-    });
-    const assuranceGates = runAssuranceGates(projectPath);
-    const minimalityReport = await buildMinimalityReport({
-        projectPath,
-        specId,
-        risk: spec.risk,
-        title: spec.title,
-        missing: result.missing,
-        extra: result.extra,
-        qualityIssues: result.qualityIssues,
-    });
+        maximumTimeoutMs: getRuntimePolicy().validation.durableLintTimeoutMs,
+    }));
+    const { assuranceGates, minimalityReport } = await runStage('assurance', 'validate assurance and minimality', async () => ({
+        assuranceGates: runAssuranceGates(projectPath),
+        minimalityReport: await buildMinimalityReport({
+            projectPath,
+            specId,
+            risk: executionSpec.risk,
+            title: executionSpec.title,
+            missing: result.missing,
+            extra: result.extra,
+            qualityIssues: result.qualityIssues,
+        }),
+    }));
     // SPEC-1050: Generate a mandatory implementation-review artifact.
-    const validationReport = await writeImplementationReviewReport({
+    const validationReport = await runStage('compliance', 'validate spec compliance', () => writeImplementationReviewReport({
         projectId,
         specId,
-        spec,
+        spec: executionSpec,
         projectPath,
         score: result.score,
         lintPassed: lintCheck.passed,
         conventionRegression: regressionDetected,
         minimalityReport: minimalityReport ?? undefined,
         signal: getToolExecutionSignal(),
-    });
+    }));
     const effectiveResult = buildEffectiveValidationResult(result, validationReport.specCompliance);
     const qualityGateSummary = buildQualityGateSummary({
         conventionViolations,
@@ -299,7 +377,7 @@ export async function executeValidate(args, server) {
     });
     const output = {
         specId,
-        title: spec.title,
+        title: executionSpec.title,
         score: effectiveResult.score,
         fieldsImplemented: effectiveResult.fieldsImplemented,
         fieldsTotal: effectiveResult.fieldsTotal,
@@ -654,7 +732,9 @@ function buildValidateStructuredContent(args) {
         ...args.result.missing.map((missing) => `missing: ${missing}`),
         ...args.indeterminate.map((item) => `indeterminate: ${item}`),
         ...args.qualityGateSummary.failures.map((failure) => `gate: ${failure}`),
-        ...args.qualityIssues.map((issue) => `${issue.rule}: ${issue.message}`),
+        ...args.qualityIssues
+            .filter((issue) => isBlockingQualitySeverity(issue.severity))
+            .map((issue) => `${issue.rule}: ${issue.message}`),
     ];
     const risks = [
         ...args.conventionCompliance.violations.map((violation) => violation.message),

package/dist/transports/http-transport.js

@@ -41,7 +41,7 @@ function setSecurityHeaders(res) {
 function setCorsHeaders(res, corsOrigin) {
     res.setHeader('Access-Control-Allow-Origin', corsOrigin);
     res.setHeader('Access-Control-Allow-Methods', 'GET, POST, DELETE, OPTIONS');
-    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept, Authorization, x-api-key, mcp-session-id, Mcp-Session-Id, Last-Event-ID, x-planu-license-key');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type, Accept, Authorization, x-api-key, mcp-session-id, Mcp-Session-Id, Last-Event-ID');
     res.setHeader('Access-Control-Expose-Headers', 'Content-Type, mcp-session-id, Mcp-Session-Id');
 }
 function handleHealth(res) {
@@ -107,16 +107,14 @@ async function handlePost(req, res, sessionId, serverFactory, requestSignal) {
         res.end(JSON.stringify({ error: 'Invalid JSON in request body' }));
         return;
     }
-    // Existing session — wrap in session context for per-session license
+    // Existing session — preserve isolated cancellation and identity context.
     if (sessionId) {
         const entry = sessions.get(sessionId);
         if (entry) {
-            await runWithSessionContext({ sessionId, licenseKey: entry.licenseKey, signal: requestSignal }, () => handleNodeTransportRequest(entry.transport, req, res, parsedBody));
+            await runWithSessionContext({ sessionId, signal: requestSignal }, () => handleNodeTransportRequest(entry.transport, req, res, parsedBody));
             return;
         }
     }
-    // Extract per-session license key from HTTP header (hosted multi-tenant mode)
-    const licenseKey = req.headers['x-planu-license-key']?.trim() ?? undefined;
     // New session — create transport and connect a new server instance
     const transport = new WebStandardStreamableHTTPServerTransport({
         sessionIdGenerator: () => randomUUID(),
@@ -130,10 +128,10 @@ async function handlePost(req, res, sessionId, serverFactory, requestSignal) {
     };
     const sessionServer = serverFactory();
     await sessionServer.connect(transport);
-    await runWithSessionContext({ sessionId: transport.sessionId ?? sessionId ?? 'unknown', licenseKey, signal: requestSignal }, () => handleNodeTransportRequest(transport, req, res, parsedBody));
+    await runWithSessionContext({ sessionId: transport.sessionId ?? sessionId ?? 'unknown', signal: requestSignal }, () => handleNodeTransportRequest(transport, req, res, parsedBody));
     const newSessionId = transport.sessionId;
     if (newSessionId) {
-        sessions.set(newSessionId, { transport, server: sessionServer, licenseKey });
+        sessions.set(newSessionId, { transport, server: sessionServer });
     }
 }
 async function handleMcpRequest(req, res, serverFactory, corsOrigin) {
@@ -176,7 +174,7 @@ async function handleMcpRequest(req, res, serverFactory, corsOrigin) {
             if (sessionId) {
                 const entry = sessions.get(sessionId);
                 if (entry) {
-                    await runWithSessionContext({ sessionId, licenseKey: entry.licenseKey, signal: cancellation.signal }, () => handleNodeTransportRequest(entry.transport, req, res));
+                    await runWithSessionContext({ sessionId, signal: cancellation.signal }, () => handleNodeTransportRequest(entry.transport, req, res));
                     return;
                 }
             }

package/dist/transports/mcp-types.d.ts

@@ -4,7 +4,5 @@ export type McpServerFactory = () => McpServer;
 export interface SessionEntry {
     transport: WebStandardStreamableHTTPServerTransport;
     server: McpServer;
-    /** Per-session license key from HTTP header (hosted multi-tenant mode) */
-    licenseKey?: string;
 }
 //# sourceMappingURL=mcp-types.d.ts.map

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/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/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,14 +9,6 @@ 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;
@@ -140,7 +134,7 @@ export interface GapsLogChainResultRs {
     totalEntries: number;
     brokenAt: number | null;
 }
-export interface SearchResult {
+export interface NativeVectorSearchResult {
     id: string;
     similarity: number;
 }
@@ -233,7 +227,7 @@ 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;
     macosKeychainSet?(account: string, secret: Buffer): Promise<void>;

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/docs.d.ts

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