@planu/cli 4.13.0 → 5.0.0

package/dist/engine/execution/job-executor.js

@@ -0,0 +1,140 @@
+import { isNativeWorkerOperation } from './native-worker-protocol.js';
+import { runNativeWorkerOperation } from './native-worker-runtime.js';
+import { reportClassifiedDegradation } from '../../errors/classified-degradation.js';
+const DEFAULT_WORKSPACE_ID = 'global';
+const DEFAULT_LEASE_MS = 5_000;
+const DEFAULT_HEARTBEAT_MS = 25;
+const DEFAULT_MAX_CONCURRENCY = 2;
+const MAX_CONCURRENCY = 8;
+const RUNNABLE_STATES = new Set(['accepted', 'checkpointed']);
+/** Claims and executes allowlisted native jobs while preserving lease and cancellation fencing. */
+export class DurableJobExecutor {
+    runtime;
+    workerId;
+    leaseMs;
+    heartbeatMs;
+    maxConcurrency;
+    runNative;
+    constructor(options) {
+        requireIdentifier(options.workerId, 'workerId');
+        this.leaseMs = options.leaseMs ?? DEFAULT_LEASE_MS;
+        this.heartbeatMs = options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+        this.maxConcurrency = options.maxConcurrency ?? DEFAULT_MAX_CONCURRENCY;
+        if (!Number.isSafeInteger(this.leaseMs) || this.leaseMs < 100 || this.leaseMs > 60_000) {
+            throw new Error('[Planu] executor leaseMs must be an integer between 100 and 60000');
+        }
+        if (!Number.isSafeInteger(this.heartbeatMs) ||
+            this.heartbeatMs < 10 ||
+            this.heartbeatMs >= this.leaseMs / 2) {
+            throw new Error('[Planu] executor heartbeatMs must be at least 10 and below half the lease');
+        }
+        if (!Number.isSafeInteger(this.maxConcurrency) ||
+            this.maxConcurrency < 1 ||
+            this.maxConcurrency > MAX_CONCURRENCY) {
+            throw new Error(`[Planu] executor maxConcurrency must be between 1 and ${String(MAX_CONCURRENCY)}`);
+        }
+        this.runtime = options.runtime;
+        this.workerId = options.workerId;
+        this.runNative = options.runNative ?? runNativeWorkerOperation;
+    }
+    /** Execute one bounded batch. Jobs not claimed by this worker remain untouched. */
+    async runOnce(projectId, workspaceId = DEFAULT_WORKSPACE_ID) {
+        requireIdentifier(projectId, 'projectId');
+        requireIdentifier(workspaceId, 'workspaceId');
+        const candidates = this.runtime
+            .list(projectId, workspaceId)
+            .filter((job) => RUNNABLE_STATES.has(job.state))
+            .slice(0, this.maxConcurrency);
+        return Promise.all(candidates.map((job) => this.execute({
+            operationId: job.id,
+            projectId: job.projectId,
+            workspaceId: job.workspaceId,
+        })));
+    }
+    async execute(identity) {
+        const claimed = this.runtime.claim({
+            ...identity,
+            workerId: this.workerId,
+            leaseMs: this.leaseMs,
+        });
+        if (!claimed) {
+            return this.runtime.get(identity);
+        }
+        const controller = new AbortController();
+        const heartbeat = setInterval(() => {
+            const current = this.runtime.get(identity);
+            if (current.state === 'cancelled' || current.cancelRequested) {
+                controller.abort(new Error('[Planu] Durable native job cancelled'));
+                return;
+            }
+            if (!this.runtime.renew({
+                ...identity,
+                workerId: this.workerId,
+                fencingToken: claimed.fencingToken,
+                leaseMs: this.leaseMs,
+            })) {
+                controller.abort(new Error('[Planu] Durable native job lease was lost'));
+            }
+        }, this.heartbeatMs);
+        heartbeat.unref();
+        try {
+            const payload = parseNativePayload(claimed.payload);
+            const value = await this.runNative({
+                projectId: identity.projectId,
+                operation: payload.operation,
+                payload: payload.payload,
+                deadlineAt: payload.deadlineAt,
+                requestId: identity.operationId,
+                cancellationId: payload.cancellationId ?? identity.operationId,
+                signal: controller.signal,
+            });
+            return this.runtime.complete({
+                ...identity,
+                workerId: this.workerId,
+                fencingToken: claimed.fencingToken,
+                result: value,
+            });
+        }
+        catch (error) {
+            /* reliability-optional: DURABLE_JOB_EXECUTION_FAILURE — runtime records typed failure below */
+            reportClassifiedDegradation('DURABLE_JOB_EXECUTION_FAILURE', error);
+            const current = this.runtime.get(identity);
+            if (current.state === 'cancelled') {
+                return current;
+            }
+            return this.runtime.fail({
+                ...identity,
+                workerId: this.workerId,
+                fencingToken: claimed.fencingToken,
+                error: boundedError(error),
+            });
+        }
+        finally {
+            clearInterval(heartbeat);
+        }
+    }
+}
+function parseNativePayload(value) {
+    if (!value || typeof value !== 'object') {
+        throw new Error('[Planu] Durable job payload must be an object');
+    }
+    const payload = value;
+    if (payload.kind !== 'native-worker' ||
+        !isNativeWorkerOperation(payload.operation) ||
+        !payload.payload ||
+        typeof payload.payload !== 'object' ||
+        !Number.isSafeInteger(payload.deadlineAt)) {
+        throw new Error('[Planu] Durable job payload is not an allowlisted native operation');
+    }
+    return payload;
+}
+function boundedError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return message.slice(0, 4_096) || 'Native worker failed';
+}
+function requireIdentifier(value, label) {
+    if (!value || value.length > 128 || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value)) {
+        throw new Error(`[Planu] Invalid ${label}`);
+    }
+}
+//# sourceMappingURL=job-executor.js.map

package/dist/engine/execution/job-runtime.d.ts

@@ -0,0 +1,108 @@
+import { type DurableJobRecord } from '../../storage/runtime-db.js';
+import type { DurableJobIdentity, DurableJobRuntimeOptions, WatchJobInput } from '../../types/durable-job.js';
+import type { NativeWorkerOperation } from '../../types/native-worker.js';
+export declare class DurableJobNotFoundError extends Error {
+    constructor(operationId: string);
+}
+/** Durable control plane for locally accepted long-running operations. */
+export declare class DurableJobRuntime implements Disposable {
+    private readonly database;
+    private readonly ownsDatabase;
+    constructor(options?: DurableJobRuntimeOptions);
+    /** Runtime database path for contained infrastructure workers. */
+    runtimeDatabasePath(): string;
+    accept(input: {
+        readonly projectId: string;
+        readonly workspaceId?: string;
+        readonly operationId?: string;
+        readonly payload: unknown;
+        readonly maxAttempts?: number;
+    }): DurableJobRecord;
+    acceptNative(input: {
+        readonly projectId: string;
+        readonly workspaceId?: string;
+        readonly operationId?: string;
+        readonly operation: NativeWorkerOperation;
+        readonly payload: Readonly<Record<string, unknown>>;
+        readonly deadlineAt: number;
+        readonly cancellationId?: string;
+        readonly maxAttempts?: number;
+    }): DurableJobRecord;
+    get(input: DurableJobIdentity): DurableJobRecord;
+    /** Return the allowlisted public projection for one job and its current queue scope. */
+    observe(input: DurableJobIdentity | DurableJobRecord): ReturnType<typeof publicJobObservation>;
+    list(projectId: string, workspaceId?: string): readonly DurableJobRecord[];
+    listRunnableScopes(): readonly {
+        projectId: string;
+        workspaceId: string;
+    }[];
+    claim(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly leaseMs: number;
+    }): DurableJobRecord | undefined;
+    renew(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly leaseMs: number;
+        readonly fencingToken: number;
+    }): boolean;
+    recordProgress(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly leaseMs: number;
+        readonly fencingToken: number;
+        readonly checkpoint: unknown;
+    }): DurableJobRecord;
+    checkpoint(input: DurableJobIdentity & {
+        readonly workerId: string;
+        readonly fencingToken: number;
+        readonly checkpoint: unknown;
+    }): 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;
+    retry(input: DurableJobIdentity): DurableJobRecord;
+    restart(input: DurableJobIdentity): DurableJobRecord;
+    restartReceiptPublication(input: DurableJobIdentity): DurableJobRecord;
+    restartWithPayload(input: DurableJobIdentity & {
+        readonly payload: unknown;
+    }): DurableJobRecord;
+    cancel(input: DurableJobIdentity): DurableJobRecord;
+    watch(input: WatchJobInput): Promise<DurableJobRecord>;
+    close(): void;
+    [Symbol.dispose](): void;
+    private requireJob;
+    private leaseInput;
+}
+/** Stable watcher cursor that detects state changes even within one clock millisecond. */
+export declare function durableJobCursor(job: DurableJobRecord): string;
+/** Build a privacy-safe job projection from existing durable records. */
+export declare function publicJobObservation(job: DurableJobRecord, scopeJobs: readonly DurableJobRecord[], now?: number): {
+    id: string;
+    projectId: string;
+    workspaceId: string;
+    state: DurableJobRecord['state'];
+    checkpoint?: unknown;
+    result?: unknown;
+    error?: string;
+    attempts: number;
+    maxAttempts: number;
+    cancelRequested: boolean;
+    createdAt: string;
+    updatedAt: string;
+    queue: {
+        status: 'active' | 'queued' | 'terminal';
+        position: number | null;
+        aheadCount: number;
+        capacity: number;
+        remainingBudgetMs: number;
+    };
+};
+/** Stable public cursor: queue movement and semantic progress count, leases and time do not. */
+export declare function publicJobCursor(job: ReturnType<typeof publicJobObservation>): string;
+//# sourceMappingURL=job-runtime.d.ts.map

package/dist/engine/execution/job-runtime.js

@@ -0,0 +1,328 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { RuntimeDatabase, } from '../../storage/runtime-db.js';
+import { resolveStorageLayout } from '../../storage/storage-layout.js';
+import { getRuntimePolicy } from '../runtime-policy.js';
+import { isNativeWorkerOperation } from './native-worker-protocol.js';
+import { getExecutionContext } from './context.js';
+import { sanitizePublicJobValue } from './public-job-sanitizer.js';
+const DEFAULT_WORKSPACE_ID = 'global';
+const MAX_WATCH_MS = 30_000;
+const TERMINAL_STATES = new Set(['cancelled', 'failed', 'dead-letter', 'completed']);
+const DURATION_ONLY_CHECKPOINT_KEYS = new Set(['durationMs', 'elapsedMs']);
+export class DurableJobNotFoundError extends Error {
+    constructor(operationId) {
+        super(`[Planu] Job ${operationId} was not found`);
+        this.name = 'DurableJobNotFoundError';
+    }
+}
+/** Durable control plane for locally accepted long-running operations. */
+export class DurableJobRuntime {
+    database;
+    ownsDatabase;
+    constructor(options = {}) {
+        this.database = new RuntimeDatabase({
+            path: options.databasePath ?? resolveStorageLayout().runtimeDatabase,
+        });
+        this.ownsDatabase = true;
+        this.database.recoverExpiredJobs();
+    }
+    /** Runtime database path for contained infrastructure workers. */
+    runtimeDatabasePath() {
+        return this.database.path;
+    }
+    accept(input) {
+        const operationId = input.operationId ?? randomUUID();
+        const workspaceId = input.workspaceId ?? DEFAULT_WORKSPACE_ID;
+        this.database.enqueueJob({
+            id: operationId,
+            projectId: input.projectId,
+            workspaceId,
+            payload: input.payload,
+            maxAttempts: input.maxAttempts,
+        });
+        return this.requireJob({ operationId, projectId: input.projectId, workspaceId });
+    }
+    acceptNative(input) {
+        if (!isNativeWorkerOperation(input.operation)) {
+            throw new Error('[Planu] Native worker operation is not allowlisted');
+        }
+        if (!Number.isSafeInteger(input.deadlineAt) || input.deadlineAt <= Date.now()) {
+            throw new Error('[Planu] Native durable job requires a future absolute deadline');
+        }
+        const payload = {
+            kind: 'native-worker',
+            operation: input.operation,
+            payload: input.payload,
+            deadlineAt: input.deadlineAt,
+            ...(input.cancellationId === undefined ? {} : { cancellationId: input.cancellationId }),
+        };
+        return this.accept({
+            projectId: input.projectId,
+            workspaceId: input.workspaceId,
+            operationId: input.operationId,
+            payload,
+            maxAttempts: input.maxAttempts,
+        });
+    }
+    get(input) {
+        return this.requireJob(input);
+    }
+    /** Return the allowlisted public projection for one job and its current queue scope. */
+    observe(input) {
+        const job = 'id' in input ? input : this.requireJob(input);
+        return publicJobObservation(job, this.list(job.projectId, job.workspaceId));
+    }
+    list(projectId, workspaceId = DEFAULT_WORKSPACE_ID) {
+        return this.database.listJobs(projectId, workspaceId);
+    }
+    listRunnableScopes() {
+        return this.database.listRunnableJobScopes();
+    }
+    claim(input) {
+        return this.database.claimJob(this.leaseInput(input));
+    }
+    renew(input) {
+        return this.database.renewJobLease(this.leaseInput(input));
+    }
+    recordProgress(input) {
+        return this.database.recordJobProgress({
+            ...this.leaseInput(input),
+            checkpoint: input.checkpoint,
+        });
+    }
+    checkpoint(input) {
+        return this.database.checkpointJob({
+            ...this.leaseInput({ ...input, leaseMs: 100 }),
+            checkpoint: input.checkpoint,
+        });
+    }
+    complete(input) {
+        return this.database.completeJob({
+            ...this.leaseInput({ ...input, leaseMs: 100 }),
+            result: input.result,
+        });
+    }
+    fail(input) {
+        return this.database.failJob({
+            ...this.leaseInput({ ...input, leaseMs: 100 }),
+            error: input.error,
+        });
+    }
+    retry(input) {
+        return this.database.retryJob(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId);
+    }
+    restart(input) {
+        return this.database.restartJob(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId);
+    }
+    restartReceiptPublication(input) {
+        return this.database.restartReceiptPublication(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId, {
+            logMaxBytes: getRuntimePolicy().validation.receiptCheckpointLogMaxBytes,
+            resultMaxBytes: getRuntimePolicy().validation.receiptCheckpointResultMaxBytes,
+        });
+    }
+    restartWithPayload(input) {
+        return this.database.restartJobWithPayload(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId, input.payload);
+    }
+    cancel(input) {
+        try {
+            return this.database.cancelJob(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId);
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.endsWith('was not found')) {
+                throw new DurableJobNotFoundError(input.operationId);
+            }
+            throw error;
+        }
+    }
+    async watch(input) {
+        const requestedTimeoutMs = input.timeoutMs ?? 10_000;
+        const pollIntervalMs = input.pollIntervalMs ?? 50;
+        if (!Number.isSafeInteger(requestedTimeoutMs) ||
+            requestedTimeoutMs < 0 ||
+            requestedTimeoutMs > MAX_WATCH_MS) {
+            throw new Error(`[Planu] timeoutMs must be an integer between 0 and ${String(MAX_WATCH_MS)}`);
+        }
+        if (!Number.isSafeInteger(pollIntervalMs) || pollIntervalMs < 10 || pollIntervalMs > 1_000) {
+            throw new Error('[Planu] pollIntervalMs must be an integer between 10 and 1000');
+        }
+        const parent = getExecutionContext();
+        const timeoutMs = Math.min(requestedTimeoutMs, Math.floor(parent?.remainingMs() ?? MAX_WATCH_MS));
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            const job = this.requireJob(input);
+            const cursor = publicJobCursor(this.observe(job));
+            if (TERMINAL_STATES.has(job.state) ||
+                input.afterCursor === undefined ||
+                cursor !== input.afterCursor ||
+                Date.now() >= deadline) {
+                return job;
+            }
+            await abortableDelay(Math.min(pollIntervalMs, Math.max(0, deadline - Date.now())), [
+                input.signal,
+                parent?.signal,
+            ]);
+        }
+    }
+    close() {
+        if (this.ownsDatabase) {
+            this.database.close();
+        }
+    }
+    [Symbol.dispose]() {
+        this.close();
+    }
+    requireJob(input) {
+        const job = this.database.getJob(input.projectId, input.workspaceId ?? DEFAULT_WORKSPACE_ID, input.operationId);
+        if (!job) {
+            throw new DurableJobNotFoundError(input.operationId);
+        }
+        return job;
+    }
+    leaseInput(input) {
+        return {
+            id: input.operationId,
+            projectId: input.projectId,
+            workspaceId: input.workspaceId ?? DEFAULT_WORKSPACE_ID,
+            workerId: input.workerId,
+            leaseMs: input.leaseMs,
+            fencingToken: input.fencingToken,
+        };
+    }
+}
+/** Stable watcher cursor that detects state changes even within one clock millisecond. */
+export function durableJobCursor(job) {
+    const capacity = getRuntimePolicy().validation.workerConcurrency;
+    const status = queueStatus(job);
+    return publicJobCursor({
+        ...publicJobFields(job),
+        queue: {
+            status,
+            position: status === 'terminal' ? null : 1,
+            aheadCount: 0,
+            capacity,
+            remainingBudgetMs: remainingBudgetMs(job),
+        },
+    });
+}
+/** Build a privacy-safe job projection from existing durable records. */
+export function publicJobObservation(job, scopeJobs, now = Date.now()) {
+    const status = queueStatus(job);
+    const queueJobs = scopeJobs.filter(isQueueRelevant).filter((candidate) => !isTerminal(candidate));
+    const positionIndex = queueJobs.findIndex((candidate) => candidate.id === job.id);
+    const position = status === 'terminal' ? null : Math.max(0, positionIndex) + 1;
+    return {
+        ...publicJobFields(job),
+        queue: {
+            status,
+            position,
+            aheadCount: position === null ? 0 : position - 1,
+            capacity: getRuntimePolicy().validation.workerConcurrency,
+            remainingBudgetMs: status === 'terminal' ? 0 : remainingBudgetMs(job, now),
+        },
+    };
+}
+/** Stable public cursor: queue movement and semantic progress count, leases and time do not. */
+export function publicJobCursor(job) {
+    return createHash('sha256')
+        .update(JSON.stringify({
+        state: job.state,
+        checkpoint: omitDurationOnlyFields(job.checkpoint),
+        result: job.result,
+        error: job.error,
+        attempts: job.attempts,
+        cancelRequested: job.cancelRequested,
+        queue: {
+            status: job.queue.status,
+            position: job.queue.position,
+            aheadCount: job.queue.aheadCount,
+            capacity: job.queue.capacity,
+        },
+    }))
+        .digest('hex');
+}
+function publicJobFields(job) {
+    return {
+        id: job.id,
+        projectId: job.projectId,
+        workspaceId: job.workspaceId,
+        state: job.state,
+        ...(job.checkpoint === undefined ? {} : { checkpoint: sanitizePublicJobValue(job.checkpoint) }),
+        ...(job.result === undefined ? {} : { result: sanitizePublicJobValue(job.result) }),
+        ...(job.error === undefined ? {} : { error: sanitizePublicJobValue(job.error) }),
+        attempts: job.attempts,
+        maxAttempts: job.maxAttempts,
+        cancelRequested: job.cancelRequested,
+        createdAt: job.createdAt,
+        updatedAt: job.updatedAt,
+    };
+}
+function queueStatus(job) {
+    if (isTerminal(job)) {
+        return 'terminal';
+    }
+    return job.state === 'running' ? 'active' : 'queued';
+}
+function isTerminal(job) {
+    return TERMINAL_STATES.has(job.state);
+}
+function isQueueRelevant(job) {
+    if (!job.payload || typeof job.payload !== 'object') {
+        return true;
+    }
+    const kind = job.payload.kind;
+    return kind === undefined || kind === 'validate';
+}
+function remainingBudgetMs(job, now = Date.now()) {
+    const payload = job.payload && typeof job.payload === 'object'
+        ? job.payload
+        : undefined;
+    const explicitDeadline = payload?.deadlineAt;
+    const fallbackDeadline = Date.parse(job.createdAt) + getRuntimePolicy().validation.defaultDeadlineMs;
+    const deadline = typeof explicitDeadline === 'number' && Number.isFinite(explicitDeadline)
+        ? explicitDeadline
+        : fallbackDeadline;
+    return Math.max(0, Math.floor(deadline - now));
+}
+function omitDurationOnlyFields(value) {
+    if (Array.isArray(value)) {
+        return value.map(omitDurationOnlyFields);
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value)
+            .filter(([key]) => !DURATION_ONLY_CHECKPOINT_KEYS.has(key))
+            .map(([key, nested]) => [key, omitDurationOnlyFields(nested)]));
+    }
+    return value;
+}
+function abortableDelay(delayMs, signals) {
+    const activeSignals = signals.filter((signal) => signal !== undefined);
+    const aborted = activeSignals.find((signal) => signal.aborted);
+    if (aborted) {
+        return Promise.reject(abortReason(aborted));
+    }
+    return new Promise((resolve, reject) => {
+        const listeners = new Map();
+        const cleanup = () => {
+            for (const [signal, listener] of listeners) {
+                signal.removeEventListener('abort', listener);
+            }
+        };
+        const timer = setTimeout(() => {
+            cleanup();
+            resolve();
+        }, delayMs);
+        for (const signal of activeSignals) {
+            const listener = () => {
+                clearTimeout(timer);
+                cleanup();
+                reject(abortReason(signal));
+            };
+            listeners.set(signal, listener);
+            signal.addEventListener('abort', listener, { once: true });
+        }
+    });
+}
+function abortReason(signal) {
+    return signal.reason instanceof Error ? signal.reason : new Error('[Planu] Job watch cancelled');
+}
+//# sourceMappingURL=job-runtime.js.map

package/dist/engine/execution/native-relevance-scorer.d.ts

@@ -0,0 +1,6 @@
+export declare function findRelevantFilesNative(input: {
+    rootPath: string;
+    keywords: readonly string[];
+    limit: number;
+}): string[];
+//# sourceMappingURL=native-relevance-scorer.d.ts.map

package/dist/engine/execution/native-relevance-scorer.js

@@ -0,0 +1,64 @@
+import { fastFindFilesByExt, fastReadFiles } from '../core-bridge.js';
+// Content scoring is advisory. Keep it bounded so a create_spec acknowledgement
+// never turns into an O(project-files) content read on large repositories.
+const MAX_CONTENT_CANDIDATES = 2_048;
+function normalizedRelativePath(rootPath, filePath) {
+    const normalizedRoot = rootPath.replaceAll('\\', '/').replace(/\/$/, '');
+    const normalizedFile = filePath.replaceAll('\\', '/');
+    return normalizedFile.startsWith(`${normalizedRoot}/`)
+        ? normalizedFile.slice(normalizedRoot.length + 1)
+        : normalizedFile;
+}
+function isRelevantSourcePath(rootPath, filePath) {
+    const relativePath = normalizedRelativePath(rootPath, filePath);
+    return ((relativePath.startsWith('src/') || relativePath.startsWith('tests/')) &&
+        !relativePath.includes('/node_modules/') &&
+        !relativePath.includes('/dist/'));
+}
+export function findRelevantFilesNative(input) {
+    const keywords = [...new Set(input.keywords.map((value) => value.trim()))].filter(Boolean);
+    if (keywords.length === 0 || !Number.isSafeInteger(input.limit) || input.limit < 1) {
+        return [];
+    }
+    const candidates = fastFindFilesByExt(input.rootPath, ['ts'])
+        .filter((filePath) => isRelevantSourcePath(input.rootPath, filePath))
+        .sort((left, right) => left.localeCompare(right));
+    const scores = new Map();
+    const pathMatched = new Set();
+    for (const filePath of candidates) {
+        const pathTokens = new Set(normalizedRelativePath(input.rootPath, filePath)
+            .toLowerCase()
+            .split(/[/\\.\-_]+/)
+            .filter((token) => token.length >= 3));
+        const pathScore = keywords.filter((keyword) => pathTokens.has(keyword)).length;
+        if (pathScore > 0) {
+            scores.set(filePath, pathScore * 2);
+            pathMatched.add(filePath);
+        }
+    }
+    // Prefer files already related by path, then inspect a deterministic bounded
+    // sample for content-only matches. The previous fastFindPatterns call walked
+    // and opened every source file a second time (10s+ at 100k files).
+    const contentCandidates = [
+        ...pathMatched,
+        ...candidates.filter((filePath) => !pathMatched.has(filePath)),
+    ].slice(0, MAX_CONTENT_CANDIDATES);
+    for (const file of fastReadFiles(contentCandidates)) {
+        const content = file.content.toLowerCase();
+        let contentScore = 0;
+        for (const keyword of keywords) {
+            if (content.includes(keyword.toLowerCase())) {
+                contentScore += 1;
+            }
+        }
+        if (contentScore > 0) {
+            scores.set(file.path, (scores.get(file.path) ?? 0) + contentScore);
+        }
+    }
+    return [...scores]
+        .filter(([, score]) => score > 0)
+        .sort(([leftPath, leftScore], [rightPath, rightScore]) => rightScore === leftScore ? leftPath.localeCompare(rightPath) : rightScore - leftScore)
+        .slice(0, input.limit)
+        .map(([filePath]) => filePath);
+}
+//# sourceMappingURL=native-relevance-scorer.js.map

package/dist/engine/execution/native-worker-dispatch.d.ts

@@ -0,0 +1,3 @@
+import type { NativeWorkerRequest } from './native-worker-protocol.js';
+export declare function dispatchNativeWorkerRequest(request: NativeWorkerRequest): unknown;
+//# sourceMappingURL=native-worker-dispatch.d.ts.map