@planu/cli 4.14.1 → 5.1.1

package/dist/engine/token-optimizer/analytics.d.ts

@@ -4,7 +4,7 @@ export declare function aggregateEntries(entries: LedgerEntry[]): LedgerAggregat
 export declare function computeDailyBreakdown(entries: LedgerEntry[]): DailyBreakdown[];
 export declare function detectTrend(dailyBreakdown: DailyBreakdown[]): TrendResult;
 export declare function detectAnomalies(entries: LedgerEntry[], dailyBreakdown: DailyBreakdown[]): Anomaly[];
-export declare function computeBudgetStatus(entries: LedgerEntry[], config: BudgetConfig): LedgerBudgetStatus;
+export declare function computeBudgetStatus(entries: LedgerEntry[], config: BudgetConfig, now?: Date): LedgerBudgetStatus;
 export declare function getTopConsumers(entries: LedgerEntry[], limit?: number): TopConsumer[];
 export declare function computeOptimizationSavings(entries: LedgerEntry[]): OptimizationSavings;
 //# sourceMappingURL=analytics.d.ts.map

package/dist/engine/token-optimizer/analytics.js

@@ -41,7 +41,7 @@ function average(nums) {
     return nums.reduce((s, n) => s + n, 0) / nums.length;
 }
 function daysInCalendarMonth(year, month) {
-    return new Date(year, month, 0).getDate(); // month is 1-based here
+    return new Date(Date.UTC(year, month, 0)).getUTCDate(); // month is 1-based here
 }
 // ---------------------------------------------------------------------------
 // aggregateEntries
@@ -262,12 +262,11 @@ export function detectAnomalies(entries, dailyBreakdown) {
 // ---------------------------------------------------------------------------
 // computeBudgetStatus
 // ---------------------------------------------------------------------------
-export function computeBudgetStatus(entries, config) {
-    const now = new Date();
-    const year = now.getFullYear();
-    const month = now.getMonth() + 1; // 1-based
+export function computeBudgetStatus(entries, config, now = new Date()) {
+    const year = now.getUTCFullYear();
+    const month = now.getUTCMonth() + 1; // 1-based
     const daysInMonth = daysInCalendarMonth(year, month);
-    const daysElapsed = now.getDate();
+    const daysElapsed = now.getUTCDate();
     // Current month filter
     const monthPrefix = `${year}-${String(month).padStart(2, '0')}`;
     const monthEntries = entries.filter((e) => e.timestamp.startsWith(monthPrefix));

package/dist/engine/usage-tracker/core.d.ts

@@ -1,8 +1,8 @@
-import type { UsageEvent, PricingTier } from '../../types/index.js';
+import type { UsageEvent } from '../../types/index.js';
 /**
  * Creates a new UsageEvent object. Does NOT persist — that is storage's job.
  */
-export declare function recordUsageEvent(toolName: string, tier: PricingTier, success: boolean): UsageEvent;
+export declare function recordUsageEvent(toolName: string, success: boolean): UsageEvent;
 /**
  * Returns events within the specified time period relative to now.
  * 'all' returns the full array unchanged.

package/dist/engine/usage-tracker/core.js

@@ -6,10 +6,9 @@
 /**
  * Creates a new UsageEvent object. Does NOT persist — that is storage's job.
  */
-export function recordUsageEvent(toolName, tier, success) {
+export function recordUsageEvent(toolName, success) {
     return {
         toolName,
-        tier,
         timestamp: new Date().toISOString(),
         success,
     };

package/dist/engine/usage-tracker/index.d.ts

@@ -1,6 +1,3 @@
 export { recordUsageEvent, filterEventsByPeriod, countEventsForDate, getLastEventTimestamp, } from './core.js';
 export { calculateUsageStats, formatStatsAsMarkdown } from './stats.js';
-export { TRIAL_DAYS, calculateDaysSinceFirstRun, isTrialActive, trialDaysRemaining, getTrialLimits, } from './trial.js';
-export { COOLDOWN_MS, checkDailyLimit, checkCooldown } from './rate-limiter.js';
-export { evaluateRateLimit } from './rate-check.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/engine/usage-tracker/index.js

@@ -1,7 +1,4 @@
 // engine/usage-tracker/index.ts — Barrel re-export for usage-tracker engine module.
 export { recordUsageEvent, filterEventsByPeriod, countEventsForDate, getLastEventTimestamp, } from './core.js';
 export { calculateUsageStats, formatStatsAsMarkdown } from './stats.js';
-export { TRIAL_DAYS, calculateDaysSinceFirstRun, isTrialActive, trialDaysRemaining, getTrialLimits, } from './trial.js';
-export { COOLDOWN_MS, checkDailyLimit, checkCooldown } from './rate-limiter.js';
-export { evaluateRateLimit } from './rate-check.js';
 //# sourceMappingURL=index.js.map

package/dist/engine/usage-tracker/stats.d.ts

@@ -1,9 +1,9 @@
-import type { UsageEvent, UsageStats, ToolHealthEntry, PricingTier } from '../../types/index.js';
+import type { UsageEvent, UsageStats, ToolHealthEntry } from '../../types/index.js';
 /**
  * Computes full UsageStats from a set of events and runtime context.
  * All parameters are passed in — no I/O performed here.
  */
-export declare function calculateUsageStats(events: readonly UsageEvent[], activeSpecs: number, activeProjects: number, currentTier: PricingTier, daysSinceFirstRun: number, isTrialActive: boolean, remainingDailyCalls: number): UsageStats;
+export declare function calculateUsageStats(events: readonly UsageEvent[], activeSpecs: number, activeProjects: number): UsageStats;
 export declare function buildToolHealthBreakdown(events: readonly UsageEvent[], allKnownTools?: readonly string[]): {
     breakdown: ToolHealthEntry[];
     deadTools: string[];

package/dist/engine/usage-tracker/stats.js

@@ -6,26 +6,19 @@
  * Computes full UsageStats from a set of events and runtime context.
  * All parameters are passed in — no I/O performed here.
  */
-export function calculateUsageStats(events, activeSpecs, activeProjects, currentTier, daysSinceFirstRun, isTrialActive, remainingDailyCalls) {
+export function calculateUsageStats(events, activeSpecs, activeProjects) {
     const callsByTool = {};
-    const callsByTier = {};
     for (const event of events) {
         callsByTool[event.toolName] = (callsByTool[event.toolName] ?? 0) + 1;
-        callsByTier[event.tier] = (callsByTier[event.tier] ?? 0) + 1;
     }
     const topTools = buildTopTools(callsByTool, 10);
     const { breakdown: toolHealthBreakdown, deadTools } = buildToolHealthBreakdown(events);
     return {
         totalCalls: events.length,
         callsByTool,
-        callsByTier,
         topTools,
         activeSpecs,
         activeProjects,
-        currentTier,
-        daysSinceFirstRun,
-        isTrialActive,
-        remainingDailyCalls,
         toolHealthBreakdown,
         deadTools,
     };
@@ -82,15 +75,9 @@ export function formatStatsAsMarkdown(stats) {
     const lines = [];
     lines.push('## Usage Statistics');
     lines.push('');
-    lines.push(`**Tier:** ${stats.currentTier}`);
-    lines.push(`**Days since first run:** ${String(stats.daysSinceFirstRun)}`);
-    lines.push(`**Trial active:** ${stats.isTrialActive ? 'Yes' : 'No'}`);
     lines.push(`**Total calls:** ${String(stats.totalCalls)}`);
     lines.push(`**Active specs:** ${String(stats.activeSpecs)}`);
     lines.push(`**Active projects:** ${String(stats.activeProjects)}`);
-    if (stats.remainingDailyCalls >= 0) {
-        lines.push(`**Remaining daily calls:** ${String(stats.remainingDailyCalls)}`);
-    }
     lines.push('');
     lines.push('### Top Tools');
     lines.push('');
@@ -125,20 +112,6 @@ export function formatStatsAsMarkdown(stats) {
             lines.push(`- ${tool}`);
         }
     }
-    lines.push('');
-    lines.push('### Calls by Tier');
-    lines.push('');
-    lines.push('| Tier | Calls |');
-    lines.push('|------|-------|');
-    const tierEntries = Object.entries(stats.callsByTier);
-    if (tierEntries.length === 0) {
-        lines.push('| *(none)* | 0 |');
-    }
-    else {
-        for (const [tier, count] of tierEntries) {
-            lines.push(`| ${tier} | ${String(count)} |`);
-        }
-    }
     return lines.join('\n');
 }
 //# sourceMappingURL=stats.js.map

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

@@ -1,9 +1,9 @@
 import type { ValidationArtifactDigests, ValidationReceiptBindings } from '../../types/validation-receipt.js';
 import type { DurableValidationBindings, ValidationPhase, ValidationPhaseGraphResult, ValidationPhaseProgress } from '../../types/durable-validation.js';
 export type { DurableValidationBindings } from '../../types/durable-validation.js';
+export { gitSourceTreeDigest } from './validation-source-digest.js';
 export { createPendingValidationSubmission, createValidationSubmission, validationOperationId, validationSubmissionOperationId, } from './validation-submission.js';
 export declare function toValidationReceiptBindings(bindings: DurableValidationBindings, artifactDigests: ValidationArtifactDigests): ValidationReceiptBindings;
-export declare function gitSourceTreeDigest(projectPath: string): Promise<string>;
 /** Compute immutable validation and lifecycle-artifact bindings without trusting spec metadata. */
 export declare function computeDurableValidationBindings(input: {
     readonly canonicalProjectId: string;

package/dist/engine/validation/durable-validation.js

@@ -1,17 +1,15 @@
 import { technologyValue } from '../technology-registry.js';
 import { createHash } from 'node:crypto';
-import { execFile } from 'node:child_process';
-import { lstat, readFile, readlink } from 'node:fs/promises';
+import { readFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
-import { promisify } from 'node:util';
 import { runAbortableProcess } from '../abortable-process-runner.js';
 import { projectDataDir } from '../../storage/base-store.js';
 import { atomicWriteFile } from '../safety/atomic-write-file.js';
 import { evidenceArtifactCollectionDigest, evidenceArtifactDigest, } from '../evidence-gates/artifact-reader.js';
-import { isValidationSourcePath } from './validation-source-policy.js';
+import { gitSourceTreeDigest } from './validation-source-digest.js';
 import { PROJECT_ID as CANONICAL_PROJECT_ID } from './validation-receipt-codec.js';
+export { gitSourceTreeDigest } from './validation-source-digest.js';
 export { createPendingValidationSubmission, createValidationSubmission, validationOperationId, validationSubmissionOperationId, } from './validation-submission.js';
-const execFileAsync = promisify(execFile);
 const DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/u;
 const DEFAULT_MAX_CONCURRENCY = 2;
 const MAX_CONCURRENCY = 8;
@@ -74,83 +72,6 @@ async function readEvidenceFile(path) {
         throw new Error(`[Planu] Invalid lifecycle evidence: ${path}`, { cause: error });
     }
 }
-async function mapWithConcurrency(values, concurrency, worker) {
-    const results = new Array(values.length);
-    let cursor = 0;
-    const runners = Array.from({ length: Math.min(concurrency, values.length) }, async () => {
-        for (;;) {
-            const index = cursor;
-            cursor += 1;
-            if (index >= values.length) {
-                return;
-            }
-            results[index] = await worker(values[index]);
-        }
-    });
-    await Promise.all(runners);
-    return results;
-}
-export async function gitSourceTreeDigest(projectPath) {
-    try {
-        const gitOptions = { cwd: projectPath, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024 };
-        const [trackedResult, untrackedResult] = await Promise.all([
-            execFileAsync('git', ['ls-files', '--cached', '-z'], gitOptions),
-            execFileAsync('git', ['ls-files', '--others', '--exclude-standard', '-z'], gitOptions),
-        ]);
-        const sourceEntries = (stdout) => stdout
-            .split('\0')
-            .filter(Boolean)
-            .map((sourcePath) => ({ sourcePath, canonicalPath: sourcePath.normalize('NFC') }))
-            .filter(({ canonicalPath }) => isValidationSourcePath(canonicalPath));
-        const entriesToRead = [
-            ...sourceEntries(trackedResult.stdout),
-            ...sourceEntries(untrackedResult.stdout),
-        ].sort((left, right) => Buffer.compare(Buffer.from(left.canonicalPath), Buffer.from(right.canonicalPath)));
-        if (new Set(entriesToRead.map(({ canonicalPath }) => canonicalPath)).size !== entriesToRead.length) {
-            throw new Error('source paths collide after Unicode normalization');
-        }
-        const entries = await mapWithConcurrency(entriesToRead, MAX_CONCURRENCY, async (entry) => {
-            const { canonicalPath: path, sourcePath } = entry;
-            const absolutePath = join(projectPath, sourcePath);
-            try {
-                const stats = await lstat(absolutePath);
-                if (stats.isSymbolicLink()) {
-                    const target = (await readlink(absolutePath)).normalize('NFC');
-                    return { path, content: Buffer.from(`symlink\0${target}`, 'utf8') };
-                }
-                if (!stats.isFile()) {
-                    throw new Error(`unsupported source entry type: ${path}`);
-                }
-                return {
-                    path,
-                    content: Buffer.concat([Buffer.from('file\0'), await readFile(absolutePath)]),
-                };
-            }
-            catch (error) {
-                if (error.code === 'ENOENT') {
-                    return undefined;
-                }
-                throw error;
-            }
-        });
-        const hash = createHash('sha256');
-        hash.update('planu-source-v1\0');
-        for (const entry of entries) {
-            if (!entry) {
-                continue;
-            }
-            const pathBytes = Buffer.from(entry.path, 'utf8');
-            hash.update(`${pathBytes.length}:`);
-            hash.update(pathBytes);
-            hash.update(`${entry.content.length}:`);
-            hash.update(entry.content);
-        }
-        return `sha256:${hash.digest('hex')}`;
-    }
-    catch (error) {
-        throw new Error('[Planu] Unable to bind validation to the source tree', { cause: error });
-    }
-}
 /** Compute immutable validation and lifecycle-artifact bindings without trusting spec metadata. */
 export async function computeDurableValidationBindings(input) {
     const handoff = join(projectDataDir(input.canonicalProjectId), 'handoffs', input.specId);

package/dist/engine/validation/validation-freshness.d.ts

@@ -18,6 +18,8 @@ export declare function beginValidationFreshnessBarrier(input: {
     handoffPath: string;
     invalidateCurrentBindings?: boolean;
 }): Promise<ValidationFreshnessLease>;
+/** Stop one exact epoch and drain all invalidations accepted before closure. */
+export declare function closeValidationFreshnessLease(lease: Pick<ValidationFreshnessLease, 'projectId' | 'specId' | 'epoch'>): Promise<void>;
 /** Bind the post-watch snapshot; an event before this call makes the lease unusable. */
 export declare function bindValidationFreshnessLease(lease: ValidationFreshnessLease, bindings: ValidationReceiptBindings): Promise<boolean>;
 /** Drain invalidation work and verify epoch, generation, health, expiry and bound inputs. */
@@ -32,5 +34,13 @@ export declare function rebaselineValidationFreshnessLeaseAfterRecompute(input:
     expectedBindings: ValidationReceiptBindings;
     recompute: () => Promise<ValidationReceiptBindings>;
 }): Promise<ValidationFreshnessLease | undefined>;
-export declare function resetValidationFreshnessForTests(): void;
+export declare function resetValidationFreshnessForTests(): Promise<void>;
+/** Count-only process diagnostic; intentionally absent from the package entrypoint. */
+export declare function getValidationFreshnessDiagnosticsForTests(): {
+    readonly activeLeases: number;
+    readonly watchers: number;
+    readonly queuedInvalidations: number;
+    readonly timers: number;
+    readonly generationTotal: number;
+};
 //# sourceMappingURL=validation-freshness.d.ts.map