@zxyycom/vibe-check 0.0.1 → 0.0.2

package/types/project-run/progress-rendering/presentation.d.ts

@@ -1,8 +1,10 @@
-import type { CheckExecutionLifecycle } from "../check-execution/resolved-checks.ts";
+import type { CheckExecutionLifecycle } from "../check-execution/lifecycle.ts";
 import { type ProgressClock, type ProgressOutcomeCounts, type ProgressWriter } from "./renderer.ts";
-import type { ProjectOutputs } from "../../project-definition/project-definition.ts";
-import type { OutputStatuses } from "../output-status.ts";
+import type { ResolvedProgressRenderingOutput } from "../../project-definition/project-definition.ts";
+import type { OutputStatuses } from "../outputs/status.ts";
 export interface ProgressRendering {
+    /** Closes only an already-created file tee; it never creates a writer after pre-work termination. */
+    readonly close: () => void;
     readonly final: (input: ProgressFinalFeedback) => void;
     readonly lifecycle: CheckExecutionLifecycle;
     readonly prepared: (totalChecks: number) => void;
@@ -21,8 +23,10 @@ export interface ProgressRefreshScheduler {
 }
 export interface ProgressRenderingDependencies {
     readonly clock?: ProgressClock;
+    /** Caller-owned exact progress transcript target for this invocation; `null` keeps terminal-only output. */
+    readonly file?: string | null;
     readonly refreshScheduler?: ProgressRefreshScheduler;
     readonly writerFactory?: ProgressWriterFactory;
 }
-/** Owns progress writer lifecycle and rendering; failed writers are permanently muted. */
-export declare function createProgressRendering(configuration: ProjectOutputs["progressRendering"], statuses: OutputStatuses, dependencies?: ProgressRenderingDependencies): ProgressRendering;
+/** Owns terminal progress and its optional file tee; terminal output survives a file-only failure. */
+export declare function createProgressRendering(configuration: ResolvedProgressRenderingOutput, statuses: OutputStatuses, dependencies?: ProgressRenderingDependencies): ProgressRendering;

package/types/project-run/progress-rendering/renderer-formatting.d.ts

@@ -1,4 +1,6 @@
 import type { CheckMessage, CheckOutcome } from "../../check/check.ts";
+import type { CoreRecord } from "../../check-settlement/facts.ts";
+import type { ResolvedProgressRenderingOutput } from "../../project-definition/project-definition.ts";
 import type { ProgressFeedback } from "./renderer.ts";
 export declare function formatRunningRow(input: Readonly<{
     readonly displayIndex: number;
@@ -9,14 +11,20 @@ export declare function formatRunningRow(input: Readonly<{
 export declare function shouldPresentSettledFeedback(feedback: Extract<ProgressFeedback, {
     readonly kind: "settled";
 }>): boolean;
+export declare function isFlagConditionNotMatchedFeedback(feedback: Extract<ProgressFeedback, {
+    readonly kind: "settled";
+}>): boolean;
+export declare function formatFlagConditionNotMatchedBlock(displayNames: readonly [string, ...string[]]): string;
 export declare function formatSettledBlock(input: Readonly<{
     readonly completionOrdinal: number;
     readonly displayName: string;
     readonly durationMs: number | null;
     readonly messages: readonly CheckMessage[];
     readonly outcome: CheckOutcome;
+    readonly records: readonly CoreRecord[];
     readonly totalChecks: number;
     readonly usesColor: boolean;
+    readonly progressRendering: ResolvedProgressRenderingOutput;
 }>): string;
 export declare function formatFinalSummary(input: Extract<ProgressFeedback, {
     readonly kind: "final";

package/types/project-run/progress-rendering/renderer-lifecycle.d.ts

@@ -1,21 +1,26 @@
 import type { ProgressClock, ProgressFeedback, ProgressRenderer, ProgressWriter } from "./renderer.ts";
+import type { ResolvedProgressRenderingOutput } from "../../project-definition/project-definition.ts";
 /** Maintains the mutable lifecycle state and the TTY-only running terminal region. */
 export declare class ProgressRendererController implements ProgressRenderer {
     readonly refreshesRunningRegion: boolean;
     private readonly clock;
     private readonly writer;
     private completedCount;
+    private readonly flagConditionNotMatchedDisplayNames;
     private preparedTotal;
     private renderedRunningRows;
     private readonly running;
     private readonly usesColor;
-    constructor(writer: ProgressWriter, clock: ProgressClock);
+    private readonly progressRendering;
+    constructor(writer: ProgressWriter, clock: ProgressClock, progressRendering: ResolvedProgressRenderingOutput);
     refresh(): void;
     render(feedback: ProgressFeedback): void;
     private prepare;
     private start;
     private settle;
     private finish;
+    private completeFlagControl;
+    private flushFlagConditionNotMatchedChecks;
     private eraseRunningRegion;
     private redrawRunningRegion;
     private removeRunningCheck;

package/types/project-run/progress-rendering/renderer.d.ts

@@ -1,13 +1,18 @@
 import type { CheckMessage, CheckOutcome, CheckVisibility } from "../../check/check.ts";
+import type { CoreRecord } from "../../check-settlement/facts.ts";
+import type { ResolvedProgressRenderingOutput } from "../../project-definition/project-definition.ts";
 export interface ProgressWriter {
     readonly color: boolean;
     readonly isTTY: boolean;
     readonly term: string | undefined;
+    close?(): void;
     write(content: string): void;
 }
 export type ProgressFeedback = Readonly<{
     readonly kind: "prepared";
     readonly totalChecks: number;
+} | {
+    readonly kind: "flag-control-completed";
 } | {
     readonly kind: "started";
     readonly checkId: string;
@@ -20,6 +25,7 @@ export type ProgressFeedback = Readonly<{
     readonly durationMs: number | null;
     readonly visibility: CheckVisibility;
     readonly messages: readonly CheckMessage[];
+    readonly records: readonly CoreRecord[];
 } | {
     readonly kind: "final";
     readonly execution: "cancelled" | "completed";
@@ -41,4 +47,4 @@ export interface ProgressClock {
     now(): number;
 }
 /** Product-private lifecycle presentation with one owner for feedback and its writer. */
-export declare function createProgressRenderer(writer: ProgressWriter, clock?: ProgressClock): ProgressRenderer;
+export declare function createProgressRenderer(writer: ProgressWriter, clock?: ProgressClock, progressRendering?: ResolvedProgressRenderingOutput): ProgressRenderer;

package/types/project-run/project-context.d.ts

@@ -1,7 +1,8 @@
 import type { CheckProjectContext } from "../check/check.ts";
 import type { RunControls } from "./controls/contract.ts";
+import type { ResolvedInvocationPaths } from "./invocation/paths.ts";
 /** Materializes only invocation-wide callback input; Check-local options own domain configuration. */
 export declare function createProjectContext(input: Readonly<{
     readonly controls: RunControls;
-    readonly root: string;
+    readonly paths: ResolvedInvocationPaths;
 }>): CheckProjectContext;

package/types/project-run/result.d.ts

@@ -3,69 +3,103 @@ import type { RunControlDiagnostic } from "./controls/validation-result.ts";
 import type { CheckAggregate, RunControls } from "./controls/contract.ts";
 import type { CheckMessageLevel } from "../check/check.ts";
 import type { CoreSnapshot } from "../check-settlement/facts.ts";
-import type { RunOutputStatuses } from "./output-status.ts";
+import type { RunOutputStatuses } from "./outputs/status.ts";
+/** Product 不能形成正常 Run 结果时的稳定 invocation diagnostic。 */
 export type RunDiagnostic = Readonly<{
-    readonly code: "task-graph-invalid" | "task-engine-failed" | "publication-model-failed";
+    /** 失败的 Run-owned execution 或 planning boundary；它不是任何 Check 的 terminal status。 */
+    readonly code: "admission-policy-failed" | "admission-strategy-preparation-failed" | "task-graph-invalid" | "task-engine-failed" | "publication-model-failed";
 }>;
+/** 一项 executable Check 的最终 duration readback。 */
 export type CheckDuration = Readonly<{
+    /** 与 snapshot 中 Check facts 相同的 stable Check identity。 */
     readonly checkId: string;
+    /** 已测量的 execution duration；未进入 execution 的 Check 为 `null`，不是零时长。 */
     readonly durationMs: number | null;
 }>;
+/** Run 在 Check terminal lifecycle 中接受的人读 message。 */
 export interface CheckRunMessage {
+    /** 产生 message 的 stable Check identity。 */
     readonly checkId: string;
+    /** author message 或已捕获 console output 的 presentation severity。 */
     readonly level: CheckMessageLevel;
+    /** owning Check 或 Product capture 使用的稳定 message code。 */
     readonly code: string;
+    /** 人读正文；不能代替 snapshot 中的 terminal outcome。 */
     readonly message: string;
 }
+/** 只有已形成 terminal Check facts 的 Run branch 才具备的完整结果 readback。 */
 export interface RunResultFacts {
+    /** 调用方未配置 aggregation 时为 `null`；否则是选中 Check statuses 的 invocation-level conclusion。 */
     readonly aggregate: CheckAggregate | null;
+    /** 按 canonical Check order 的 duration facts；未执行 Check 仍以 `null` 保留。 */
     readonly checkDurations: readonly CheckDuration[];
+    /** 已接受的 author 与 console-capture messages，不决定 Check outcome。 */
     readonly checkMessages: readonly CheckRunMessage[];
+    /** 已结算的完整 Check 与 supplemental Record facts。 */
     readonly snapshot: CoreSnapshot;
 }
 /** 一次 Project Run 的可判别结果；output failure 保留已结算 facts。 */
 export type RunResult = Readonly<{
+    /** Definition、RunControls 或 aggregation selection 无效；没有执行任何 Check author callback。 */
     readonly kind: "configuration";
+    /** Definition normalization 时仍可报告、但不单独阻止本 branch 的 warning。 */
     readonly definitionWarnings: readonly DefinitionWarning[];
+    /** 指向被拒绝 Definition 或 RunControls value 的 closed diagnostic。 */
     readonly diagnostic: ProjectDefinitionDiagnostic | RunControlDiagnostic;
 } | {
+    /** 配置有效，但 static Check graph 不能进入 execution planning。 */
     readonly kind: "planning";
+    /** normalized declarative Definition 的 matching signal；不包含 RunControls 或 outcome。 */
     readonly declarativeFingerprint: string;
     readonly definitionWarnings: readonly DefinitionWarning[];
+    /** 这次 planning 失败的 Product diagnostic。 */
     readonly diagnostic: RunDiagnostic;
+    /** 配置有效后各 terminal output participant 的独立状态。 */
     readonly outputs: RunOutputStatuses;
 } | {
+    /** invocation 在 Check work 开始前或 planning 中响应 caller cancellation。 */
     readonly kind: "cancelled";
     readonly declarativeFingerprint: string;
     readonly definitionWarnings: readonly DefinitionWarning[];
     readonly outputs: RunOutputStatuses;
+    /** 取消发生在尚未形成 terminal Check facts 的阶段。 */
     readonly phase: "pre-work" | "planning";
 } | {
+    /** invocation 在至少可能已开始 Check work 的 execution 阶段响应 caller cancellation。 */
     readonly kind: "cancelled";
     readonly declarativeFingerprint: string;
     readonly definitionWarnings: readonly DefinitionWarning[];
     readonly outputs: RunOutputStatuses;
+    /** 此 branch 总在 terminal Check facts 形成后的 execution cancellation 返回。 */
     readonly phase: "execution";
+    /** 按 canonical Check order 的 duration facts；未执行 Check 为 `null`。 */
     readonly checkDurations: readonly CheckDuration[];
+    /** cancellation 前已接受的 author 与 console-capture messages。 */
     readonly checkMessages: readonly CheckRunMessage[];
+    /** cancellation 时已结算的完整 Check 与 supplemental Record facts。 */
     readonly snapshot: CoreSnapshot;
 } | ({
+    /** 所有 Check 已完成 terminal settlement；不表示每项 Check 都 `passed`。 */
     readonly kind: "completed";
     readonly declarativeFingerprint: string;
     readonly definitionWarnings: readonly DefinitionWarning[];
     readonly outputs: RunOutputStatuses;
 } & RunResultFacts) | {
+    /** Product execution/settlement infrastructure 失败；不把它误表示为 Check `failed`。 */
     readonly kind: "execution";
     readonly declarativeFingerprint: string;
     readonly definitionWarnings: readonly DefinitionWarning[];
+    /** 停止正常 execution 的 Product diagnostic；本 branch 不提供 partial snapshot。 */
     readonly diagnostic: RunDiagnostic;
     readonly outputs: RunOutputStatuses;
 } | ({
+    /** Check facts 已完整结算，但至少一个 terminal output participant 失败。 */
     readonly kind: "output";
     readonly declarativeFingerprint: string;
     readonly definitionWarnings: readonly DefinitionWarning[];
+    /** 失败的 machine、progress、diagnostic 或 scheduler-measurement output 类别。 */
     readonly diagnostic: Readonly<{
-        readonly code: "machine-publication-failed" | "progress-rendering-failed" | "diagnostic-logging-failed";
+        readonly code: "machine-publication-failed" | "progress-rendering-failed" | "diagnostic-logging-failed" | "scheduler-measurement-hooks-failed";
     }>;
     readonly outputs: RunOutputStatuses;
 } & RunResultFacts)>;

package/types/project-run/run.d.ts

@@ -1,18 +1,19 @@
 import type { ProjectDefinition } from "../project-definition/project-definition.ts";
 import type { RunControls } from "./controls/contract.ts";
 import type { RunResult } from "./result.ts";
-export type { RunOutputStatus, RunOutputStatuses } from "./output-status.ts";
+export type { RunOutputStatus, RunOutputStatuses } from "./outputs/status.ts";
 export type { RunDiagnostic, RunResult } from "./result.ts";
 /**
- * 在调用方的 Bun runtime 中执行一个由项目拥有的 Project Definition。
+ * 在调用方的 Node runtime 中执行一个由项目拥有的 Project Definition。
  *
  * @param definition - Project Definition input；{@link defineConfig} 补齐 defaults，run 在 invocation 前验证。
  * @param controls - 本次 invocation context 与 outputs 使用的闭合控制值。
  * @returns ordinary configuration、planning、execution、cancellation 与 output failures 通过 `RunResult`
  * 返回；调用方先按 `kind` narrow。
- * @remarks Definition validation 关闭 authoring grammar；可选 Check preflight 组成 invocation execution barrier，
- * 并在 execution callback、dependency resolver 或 scanner 前完成。`output` branch 同时提供完整 final
- * snapshot 与 output failure diagnostic。
+ * @remarks Definition validation 关闭 authoring grammar；可选 Check preflight 在其 Task 通过直接 relation
+ * readiness 后被 Scheduler admission 时运行，并先于该 Check 自己的 execution callback。它受该 Task 的
+ * mutex、capacity、priority 与 cancellation 约束，而不是 invocation-wide barrier。`output` branch 同时提供
+ * 完整 final snapshot 与 output failure diagnostic。
  */
 export declare function run(definition: ProjectDefinition, controls?: RunControls): Promise<RunResult>;
 export declare function run(definition: unknown, controls?: unknown): Promise<RunResult>;

package/types/project-run/task-scheduler/admission-core/compiled-graph.d.ts

@@ -0,0 +1,31 @@
+import type { PlannedTask, PlannedTaskGraph } from "../graph.ts";
+interface RelationStaticIndexes {
+    readonly reverseDependencies: readonly (readonly number[])[];
+    readonly reverseMutexOccurrences: readonly (readonly number[])[];
+    readonly reverseObservations: readonly (readonly number[])[];
+}
+export interface CompiledAdmissionGraph {
+    readonly graph: PlannedTaskGraph;
+    readonly maxParallel: number;
+    readonly mutexSlotById: ReadonlyMap<string, number>;
+    readonly resourceCapacityBySlot: readonly number[];
+    readonly resourceSlotById: ReadonlyMap<string, number>;
+    readonly scopesById: ReadonlyMap<string, PlannedTaskGraph["scopes"][number]>;
+    readonly scopeSlotById: ReadonlyMap<string, number>;
+    readonly scopeSlotsByTerminalTaskSlot: readonly (readonly number[])[];
+    readonly taskById: ReadonlyMap<string, PlannedTask>;
+    readonly taskMutexSlots: readonly (readonly number[])[];
+    readonly taskResourceClaims: readonly (readonly Readonly<{
+        readonly resourceSlot: number;
+        readonly units: number;
+    }>[])[];
+    readonly taskActivatesScope: readonly boolean[];
+    readonly taskScopeSlots: readonly (number | undefined)[];
+    readonly taskSlotsById: ReadonlyMap<string, number>;
+    readonly taskIdsInPublicOrder: readonly string[];
+    readonly taskSlotsInPublicOrder: readonly number[];
+    readonly relationIndexes: RelationStaticIndexes;
+}
+/** Compiles a Scheduler-owned normalized graph once for an actual scheduler invocation. */
+export declare function compilePreparedAdmissionGraph(graph: PlannedTaskGraph, maxParallel: number): CompiledAdmissionGraph;
+export {};

package/types/project-run/task-scheduler/admission-core/core.d.ts

@@ -0,0 +1,57 @@
+import type { AdmissionGraph, AdmissionGraphInput, AdmissionRejectionReason, AdmissionSelectionValidation, AdmissionSelectionValidationRejectionReason, AdmissionState } from "../../../project-definition/scheduler-policy.ts";
+import { schedulerInspectionForCore } from "./projection.ts";
+import { createAdmissionCoreFromSchedulerSnapshot, createInitialAdmissionCoreState, type AdmissionCoreState } from "./selection.ts";
+import { admissionCandidatesForCore, scopeToActivateForCore, type AdmissionCoreSelection } from "./selection-query.ts";
+import type { SchedulerSettlementKind } from "../scheduler-decision-model.ts";
+export { compilePreparedAdmissionGraph } from "./compiled-graph.ts";
+export type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+export { admissionCandidatesForCore, createAdmissionCoreFromSchedulerSnapshot, createInitialAdmissionCoreState, schedulerInspectionForCore, scopeToActivateForCore };
+export type { AdmissionCoreSelection, AdmissionCoreState };
+export type AdmissionCoreEffect = Readonly<{
+    readonly kind: "admitted";
+    readonly taskId: string;
+}> | Readonly<{
+    readonly dependencyIds?: readonly string[];
+    readonly kind: "settled";
+    readonly settlementKind: SchedulerSettlementKind;
+    readonly taskId: string;
+}>;
+export interface AdmissionCoreTransition {
+    /** The immutable post-state for each corresponding canonical effect. */
+    readonly effectStates: readonly AdmissionCoreState[];
+    readonly effects: readonly AdmissionCoreEffect[];
+    readonly state: AdmissionCoreState;
+}
+/** 在 exact boundary validation 和一次 static compile 后创建 standalone public factory。 */
+export declare function createAdmissionGraph(input: AdmissionGraphInput): AdmissionGraph;
+/** The canonical select action used by both the public opaque handle and the real shell. */
+export declare function selectAdmissionCore(state: AdmissionCoreState, taskId: string): Readonly<{
+    readonly accepted: true;
+    readonly transition: AdmissionCoreTransition;
+} | {
+    readonly accepted: false;
+    readonly reason: AdmissionSelectionValidationRejectionReason;
+}>;
+/** The public binary settlement action. Runtime outcome validation intentionally precedes ID checks. */
+export declare function settleAdmissionCore(state: AdmissionCoreState, taskId: string, outcome: unknown): Readonly<{
+    readonly accepted: true;
+    readonly transition: AdmissionCoreTransition;
+} | {
+    readonly accepted: false;
+    readonly reason: AdmissionRejectionReason;
+}>;
+/** Applies a real running Task settlement through the same reducer, retaining private exact kinds. */
+export declare function settleRunningAdmissionCore(state: AdmissionCoreState, taskId: string, settlementKind: Extract<SchedulerSettlementKind, "completed" | "prerequisite-unsatisfied" | "failed">): Readonly<{
+    readonly accepted: true;
+    readonly transition: AdmissionCoreTransition;
+} | {
+    readonly accepted: false;
+    readonly reason: AdmissionRejectionReason;
+}>;
+/** Private cancellation stays in the reducer/effect owner but has no public AdmissionState action. */
+export declare function cancelPendingAdmissionCore(state: AdmissionCoreState): AdmissionCoreTransition;
+/** Reconciles forced dependency blocks before the real shell publishes its next decision boundary. */
+export declare function reconcileAdmissionCore(state: AdmissionCoreState): AdmissionCoreTransition;
+export declare function validateAdmissionCoreSelection(state: AdmissionCoreState, taskId: string): AdmissionSelectionValidation;
+/** Constructs the frozen opaque public wrapper. Projection work remains lazy until its getter is read. */
+export declare function admissionStateForCore(core: AdmissionCoreState): AdmissionState;

package/types/project-run/task-scheduler/admission-core/input.d.ts

@@ -0,0 +1,4 @@
+import type { AdmissionGraphInput } from "../../../project-definition/scheduler-policy.ts";
+import { type CompiledAdmissionGraph } from "./compiled-graph.ts";
+/** Validates the exact standalone boundary before compiling the Scheduler-owned graph. */
+export declare function compileAdmissionGraphInput(input: AdmissionGraphInput): CompiledAdmissionGraph;

package/types/project-run/task-scheduler/admission-core/projection.d.ts

@@ -0,0 +1,22 @@
+import type { AdmissionCatalog, AdmissionInspection } from "../../../project-definition/scheduler-policy.ts";
+import type { PlannedTask, PlannedTaskGraph } from "../graph.ts";
+import type { AdmissionCoreState } from "./selection.ts";
+import type { SchedulerSettlementKind } from "../scheduler-decision-model.ts";
+/** Materializes the public catalog only when the public getter reads it. */
+export declare function catalogForCore(state: AdmissionCoreState): AdmissionCatalog;
+export declare function inspectionForCore(state: AdmissionCoreState): AdmissionInspection;
+/** Scheduler-only projection retained for policy choice and diagnostics, not a second transition model. */
+export declare function schedulerInspectionForCore(state: AdmissionCoreState): Readonly<{
+    readonly activeScopeIds: readonly string[];
+    readonly effectiveMaxParallel: number;
+    readonly graph: PlannedTaskGraph;
+    readonly maxParallel: number;
+    readonly pendingTasks: readonly PlannedTask[];
+    readonly runningMutexes: readonly string[];
+    readonly resources: AdmissionInspection["resources"];
+    readonly runningTaskIds: readonly string[];
+    readonly settledTasks: readonly Readonly<{
+        readonly kind: SchedulerSettlementKind;
+        readonly taskId: string;
+    }>[];
+}>;

package/types/project-run/task-scheduler/admission-core/selection-index.d.ts

@@ -0,0 +1,61 @@
+import { List } from "immutable";
+import type { SchedulerSettlementKind } from "../scheduler-decision-model.ts";
+export type CoreTaskStatus = Readonly<{
+    readonly kind: "pending";
+}>
+/** Only used while adapting private partial SchedulerSnapshot test inputs. */
+ | Readonly<{
+    readonly kind: "absent";
+}> | Readonly<{
+    readonly kind: "running";
+}> | Readonly<{
+    readonly kind: "settled";
+    readonly settlementKind: SchedulerSettlementKind;
+}>;
+export declare const PENDING: CoreTaskStatus;
+export declare const ABSENT: CoreTaskStatus;
+/** Immutable.List is the persistent indexed backing for every dense selection counter. */
+export type PersistentIndexedStore<T> = Readonly<{
+    readonly values: List<T>;
+}>;
+export type NumberStore = PersistentIndexedStore<number>;
+export type StatusStore = PersistentIndexedStore<CoreTaskStatus>;
+/** Persistent leftist max-heap: task slots are the canonical forced-effect priority. */
+export type ForcedTaskQueue = undefined | Readonly<{
+    readonly left: ForcedTaskQueue;
+    readonly rank: number;
+    readonly right: ForcedTaskQueue;
+    readonly taskSlot: number;
+}>;
+/** Private dynamic index shared by the seed, delta reducer and read-only query owners. */
+export interface AdmissionSelectionIndex {
+    readonly activeScopeSlots: readonly number[];
+    readonly activeScopes: NumberStore;
+    readonly forcedQueue: ForcedTaskQueue;
+    readonly legacyRunningMutexes: readonly string[] | undefined;
+    readonly mutexHolders: NumberStore;
+    /** Per-task reverse-mutex occurrence count; candidate sieving never builds mutex payloads. */
+    readonly heldMutexBlockers: NumberStore;
+    readonly nonCompletedDependencies: NumberStore;
+    readonly pendingObservations: NumberStore;
+    readonly pendingDependencies: NumberStore;
+    readonly remainingTaskCount: number;
+    readonly resourceInUse: NumberStore;
+    readonly runningTotal: number;
+    readonly statuses: StatusStore;
+}
+export declare function persistentStatuses(values: readonly CoreTaskStatus[]): StatusStore;
+export declare function persistentNumbersFor(values: readonly number[]): NumberStore;
+export declare function statusForSelection(selection: AdmissionSelectionIndex, taskSlot: number): CoreTaskStatus;
+export declare function statusForStore(store: StatusStore, taskSlot: number): CoreTaskStatus;
+export declare function withStatusAt(store: StatusStore, taskSlot: number, value: CoreTaskStatus): StatusStore;
+export declare function numberFor(store: NumberStore, slot: number): number;
+/** Applies all occurrence deltas through one new persistent List value. */
+export declare function withNumberDeltas(store: NumberStore, deltas: readonly (readonly [number, number])[]): NumberStore;
+export declare function forcedTaskSlotFor(selection: AdmissionSelectionIndex): number | undefined;
+/** Removes just the persistent heap root; all retained branches remain shared. */
+export declare function withoutForcedTask(selection: AdmissionSelectionIndex): AdmissionSelectionIndex;
+export declare function forcedQueueFromTaskSlots(taskSlots: readonly number[]): ForcedTaskQueue;
+/** Additions are newly-ready reverse dependents, so no extant frontier is copied or sorted. */
+export declare function enqueueForcedTaskSlots(existing: ForcedTaskQueue, additions: ReadonlySet<number>): ForcedTaskQueue;
+export declare function freezeSelectionIndex(selection: AdmissionSelectionIndex): AdmissionSelectionIndex;

package/types/project-run/task-scheduler/admission-core/selection-query.d.ts

@@ -0,0 +1,28 @@
+import type { AdmissionSelectionRejectionReason } from "../../../project-definition/scheduler-policy.ts";
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import { type AdmissionSelectionIndex, type CoreTaskStatus } from "./selection-index.ts";
+import type { PlannedTask, PlannedTaskGraph } from "../graph.ts";
+type SelectionCoreState = Readonly<{
+    readonly compiled: CompiledAdmissionGraph;
+    readonly selection: AdmissionSelectionIndex;
+}>;
+export interface AdmissionCoreSelection {
+    readonly canAdmit: boolean;
+    readonly task: PlannedTask;
+}
+export declare function statusForCore(state: SelectionCoreState, taskSlot: number): CoreTaskStatus;
+export declare function isCoreComplete(state: SelectionCoreState): boolean;
+export declare function requiredTaskForCore(state: SelectionCoreState, taskSlot: number): PlannedTask;
+export declare function requiredTaskSlotForCore(state: SelectionCoreState, taskId: string): number;
+export declare function requiredScopeForCore(state: SelectionCoreState, scopeSlot: number): PlannedTaskGraph["scopes"][number];
+export declare function requiredScopeSlotForCore(state: SelectionCoreState, scopeId: string): number;
+/** Public validation and catalog payloads preserve lexical duplicate occurrences. */
+export declare function selectionRejectionForPendingTask(state: SelectionCoreState, taskSlot: number): AdmissionSelectionRejectionReason | undefined;
+export declare function isAdmissionEligibleForPendingTask(state: SelectionCoreState, taskSlot: number): boolean;
+export declare function admissionCandidatesForCore(state: SelectionCoreState): readonly AdmissionCoreSelection[];
+export declare function scopeToActivateForCore(state: SelectionCoreState, taskId: string): string | null;
+export declare function activeScopesForCore(state: SelectionCoreState): PlannedTaskGraph["scopes"][number][];
+export declare function scopeLifecycleForCore(state: SelectionCoreState, scopeSlot: number): "inactive" | "active" | "closed";
+export declare function isScopeInactiveForCore(state: SelectionCoreState, scopeSlot: number): boolean;
+export declare function effectiveMaxParallelForCore(state: SelectionCoreState): number;
+export {};

package/types/project-run/task-scheduler/admission-core/selection-seed.d.ts

@@ -0,0 +1,9 @@
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import { type AdmissionSelectionIndex, type CoreTaskStatus } from "./selection-index.ts";
+/** Builds every immutable selection index from one static graph and one exact status seed. */
+export declare function selectionIndexForSeed(compiled: CompiledAdmissionGraph, statuses: readonly CoreTaskStatus[], activeScopeIds: readonly string[] | undefined, legacyRunningMutexes: readonly string[] | undefined): AdmissionSelectionIndex;
+export declare function insertActiveScopeSlot(compiled: CompiledAdmissionGraph, slots: readonly number[], next: number): readonly number[];
+export declare function sortedActiveScopeSlots(compiled: CompiledAdmissionGraph, slots: readonly number[]): readonly number[];
+export declare function compareScopeCapacityForCompiled(compiled: CompiledAdmissionGraph, left: number, right: number): number;
+export declare function requiredTaskSlotForCompiled(compiled: CompiledAdmissionGraph, taskId: string): number;
+export declare function requiredScopeForCompiled(compiled: CompiledAdmissionGraph, scopeSlot: number): CompiledAdmissionGraph["graph"]["scopes"][number];

package/types/project-run/task-scheduler/admission-core/selection-transition.d.ts

@@ -0,0 +1,4 @@
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import { type AdmissionSelectionIndex, type CoreTaskStatus } from "./selection-index.ts";
+/** Applies one status event through staged persistent index deltas. */
+export declare function transitionIndexedSelection(compiled: CompiledAdmissionGraph, selection: AdmissionSelectionIndex, taskSlot: number, status: CoreTaskStatus, activatedScopeSlot: number | undefined): AdmissionSelectionIndex;

package/types/project-run/task-scheduler/admission-core/selection.d.ts

@@ -0,0 +1,20 @@
+import type { CompiledAdmissionGraph } from "./compiled-graph.ts";
+import { type AdmissionSelectionIndex } from "./selection-index.ts";
+import type { SchedulerSettlementKind, SchedulerSnapshot } from "../scheduler-decision-model.ts";
+/** Private immutable core passed among Scheduler decision, policy and effect owners. */
+export interface AdmissionCoreState {
+    readonly compiled: CompiledAdmissionGraph;
+    /** Selection representation remains private to this lifecycle module family. */
+    readonly selection: AdmissionSelectionIndex;
+}
+/** Starts from the canonical all-pending selection seed. */
+export declare function createInitialAdmissionCoreState(compiled: CompiledAdmissionGraph): AdmissionCoreState;
+/** Seeds from a shell snapshot without exposing a mutable shell view. */
+export declare function createAdmissionCoreFromSchedulerSnapshot(compiled: CompiledAdmissionGraph, snapshot: SchedulerSnapshot): AdmissionCoreState;
+/** Produces an immutable successor for a validated pending-to-running admission. */
+export declare function admitTaskForCore(state: AdmissionCoreState, taskSlot: number): AdmissionCoreState;
+/** Produces an immutable successor for one already-validated settlement event. */
+export declare function settleTaskForCore(state: AdmissionCoreState, taskSlot: number, settlementKind: SchedulerSettlementKind): AdmissionCoreState;
+/** Pops the forced max-heap before recording its canonical blocked settlement. */
+export declare function settleForcedTaskForCore(state: AdmissionCoreState, taskSlot: number): AdmissionCoreState;
+export declare function nextForcedTaskForCore(state: AdmissionCoreState): number | undefined;

package/types/project-run/task-scheduler/admission-scope-layers.d.ts

@@ -0,0 +1,8 @@
+import type { SchedulerInspection } from "./scheduler-decision-inspection.ts";
+import type { PlannedTask, PlannedTaskGraph, PlannedTaskScope } from "./graph.ts";
+/** Returns the declared scope for one Task without inferring membership from activation state. */
+export declare function scopeForTask(graph: PlannedTaskGraph, task: PlannedTask): PlannedTaskScope | undefined;
+/** Returns the inactive constrained scope that this Task would activate. */
+export declare function tighteningScopeForTask(graph: PlannedTaskGraph, inspection: SchedulerInspection, task: PlannedTask): PlannedTaskScope | undefined;
+/** Reports whether a Task continues an active scope that constrains root parallelism. */
+export declare function isConstrainedScopeContinuation(graph: PlannedTaskGraph, inspection: SchedulerInspection, task: PlannedTask): boolean;

package/types/project-run/task-scheduler/admission-selection-policy.d.ts

@@ -0,0 +1,31 @@
+import type { PlannedTask, PlannedTaskGraph } from "./graph.ts";
+import type { AdmissionCoreState } from "./admission-core/core.ts";
+import type { SchedulerInspection } from "./scheduler-decision-inspection.ts";
+import type { AdmissionPolicyContext, SchedulerGraphSnapshot } from "../../project-definition/project-definition.ts";
+export interface AdmissionCandidate {
+    readonly canAdmit: boolean;
+    readonly task: PlannedTask;
+}
+export interface AdmissionPolicyInput {
+    /** Shared immutable core at this decision boundary; only custom context projects its public handle. */
+    readonly admissionCore: AdmissionCoreState;
+    /** Scheduler-owned decision-boundary measurement, present only for custom policy. */
+    readonly measurement?: AdmissionPolicyContext["measurement"];
+    readonly candidates: readonly AdmissionCandidate[];
+    readonly graph: PlannedTaskGraph;
+    readonly graphSnapshot: SchedulerGraphSnapshot;
+    readonly inspection: SchedulerInspection;
+}
+export type AdmissionPolicyDecision = Readonly<{
+    readonly kind: "select";
+    readonly taskId: string;
+}> | Readonly<{
+    readonly kind: "wait";
+}>;
+/** A Product-private pure admission policy; it receives no executor or mutable scheduler state. */
+export interface AdmissionSelectionPolicy {
+    /** Only custom policies require Scheduler sampling before every callback. */
+    readonly requiresMeasurement?: true;
+    readonly decide: (input: AdmissionPolicyInput) => AdmissionPolicyDecision;
+}
+export declare const staticAdmissionSelectionPolicy: AdmissionSelectionPolicy;

package/types/project-run/task-scheduler/critical-path-ranking.d.ts

@@ -0,0 +1,19 @@
+import type { SchedulerGraphSnapshot } from "../../project-definition/project-definition.ts";
+/** The pure ranking algorithm only needs immutable estimated durations keyed by Task ID. */
+export interface SchedulerCriticalPathPredictionSnapshot {
+    readonly predictions: readonly Readonly<{
+        readonly estimatedDurationMs: number;
+        readonly taskId: string;
+    }>[];
+}
+export interface SchedulerCriticalPathScore {
+    readonly criticalPathScore: number;
+    readonly taskId: string;
+}
+/** A graph-derived immutable score table; it retains no dependency or authored-input payload. */
+export interface SchedulerCriticalPathSnapshot {
+    readonly scores: readonly SchedulerCriticalPathScore[];
+}
+/** Computes directed dependsOn + observes downstream scores once before Scheduler admission. */
+export declare function createSchedulerCriticalPathSnapshot(graph: SchedulerGraphSnapshot, prediction: SchedulerCriticalPathPredictionSnapshot): SchedulerCriticalPathSnapshot;
+export declare function criticalPathScoreForTask(snapshot: SchedulerCriticalPathSnapshot, taskId: string): number | undefined;

package/types/project-run/task-scheduler/custom-admission-policy.d.ts

@@ -0,0 +1,6 @@
+import type { AdmissionPolicyContext, AdmissionProposal } from "../../project-definition/project-definition.ts";
+import type { AdmissionSelectionPolicy } from "./admission-selection-policy.ts";
+import { type AdmissionPolicyFaultCategory } from "./scheduler-admission-decision.ts";
+/** Adapts the public, trusted callback to the Scheduler's private pure policy seam. */
+export declare function admissionSelectionPolicyFor(decide: (this: void, context: AdmissionPolicyContext) => AdmissionProposal): AdmissionSelectionPolicy;
+export type { AdmissionPolicyFaultCategory };