@blxzer/pactile 0.5.0 → 0.6.0-beta.4

package/dist/pactile/registry.js

@@ -1,20 +1,22 @@
-import { parseCapabilityBindingV1, parseTileManifestV1, } from "@blxzer/pactile-core";
-import { compileTileComposition } from "./tiles/compiler.js";
+import fs from "node:fs";
+import path from "node:path";
+import { ASSURANCE_LEVELS_V1, canonicalizePactileJsonV1, fingerprintPactileContractV1, parseCapabilityBindingV1, parseTileManifestV1, } from "../core/index.js";
+import * as taskKernelApi from "../core/task/index.js";
+import { approvedExecuteTask } from "./task/authorization.js";
+import { resolveSelectedTask, resolveTaskDir } from "./task/session.js";
+import { compileTileComposition, intersectTilePolicies } from "./tiles/compiler.js";
 import { buildTileCatalog, } from "./tiles/catalog.js";
-import { loadBaselineTileContent, } from "./tiles/content/baseline/index.js";
-import { loadOndemandTileContent, } from "./tiles/content/ondemand/index.js";
+import { loadBaselineTileContent, BASELINE_TILE_IDS, } from "./tiles/content/baseline/index.js";
+import { loadOndemandTileContent, ONDEMAND_TILE_IDS, } from "./tiles/content/ondemand/index.js";
 import { buildSharedProjectionPlan, } from "./projection/shared/index.js";
-import { buildCursorProjectionPlan, } from "./adapters/cursor/index.js";
 import { buildCodexProjectionPlan, } from "./adapters/codex/index.js";
 import { tileFingerprint, } from "./tiles/loader.js";
+import { decideTileSelection, normalizeTileSelectionReplayInput, prepareTileSelection, replayTileSelectionDecision, taskTileSelectionRequest, createTileSelectionLifecycleFailureReceipt, } from "./tiles/selection.js";
+import { adviseTileSelectionWithJevV1, } from "./tiles/jev-selection.js";
+import { resolveJevProjectEgressPolicyV1 } from "./jev/project-policy.js";
+import { replayTileSelectionSnapshot, writeTileSelectionSnapshot, } from "./tiles/selection-receipts.js";
 /** The adapters that Pactile can compose in this batch. */
 export const PACTILE_PLATFORM_REGISTRY = {
-    cursor: {
-        platform: "cursor",
-        adapterId: "adapter.cursor",
-        host: "cursor",
-        capabilities: ["commands", "rules", "agents", "hooks", "mcp"],
-    },
     codex: {
         platform: "codex",
         adapterId: "adapter.codex",
@@ -23,14 +25,11 @@ export const PACTILE_PLATFORM_REGISTRY = {
     },
 };
 export function listPactilePlatforms() {
-    return [
-        PACTILE_PLATFORM_REGISTRY.cursor,
-        PACTILE_PLATFORM_REGISTRY.codex,
-    ];
+    return [PACTILE_PLATFORM_REGISTRY.codex];
 }
 export function getPactilePlatform(platform) {
-    if (platform === "cursor" || platform === "codex")
-        return PACTILE_PLATFORM_REGISTRY[platform];
+    if (platform === "codex")
+        return PACTILE_PLATFORM_REGISTRY.codex;
     return null;
 }
 /** Load and validate the twenty bundled B2 Tiles through the existing loader. */
@@ -47,6 +46,626 @@ export function loadBatch2TileCatalog() {
         };
     return buildTileCatalog([...baseline.data, ...ondemand.data]);
 }
+/** Build the bundled baseline/on-demand registry facts without changing M0 Tile manifests. */
+export function loadBatch2TileSelectionSurface(lifecycleByRef) {
+    if (!isRecord(lifecycleByRef))
+        return {
+            success: false,
+            diagnostics: [{ code: "tile-selection-lifecycle-incomplete", tileRef: null, relatedRef: null, path: "$.lifecycleByRef" }],
+        };
+    const loaded = loadBatch2TileCatalog();
+    if (!loaded.success)
+        return loaded;
+    const baseline = new Set(BASELINE_TILE_IDS);
+    const ondemand = new Set(ONDEMAND_TILE_IDS);
+    const refs = new Set(loaded.data.entries.map((entry) => entry.ref));
+    for (const [ref, lifecycle] of Object.entries(lifecycleByRef)) {
+        if (!refs.has(ref))
+            return {
+                success: false,
+                diagnostics: [{ code: "tile-selection-unknown-lifecycle-ref", tileRef: null, relatedRef: null, path: "$.lifecycleByRef" }],
+            };
+        if (!["active", "registered", "deprecated", "disabled", "retired", "degraded"].includes(lifecycle))
+            return {
+                success: false,
+                diagnostics: [{ code: "tile-selection-invalid-lifecycle", tileRef: ref, relatedRef: null, path: "$.lifecycleByRef" }],
+            };
+    }
+    if (Object.keys(lifecycleByRef).length !== refs.size)
+        return {
+            success: false,
+            diagnostics: [{ code: "tile-selection-lifecycle-incomplete", tileRef: null, relatedRef: null, path: "$.lifecycleByRef" }],
+        };
+    const facts = [];
+    for (const entry of loaded.data.entries) {
+        const id = entry.manifest.identity.id;
+        const tier = baseline.has(id)
+            ? "baseline"
+            : ondemand.has(id)
+                ? "on-demand"
+                : null;
+        if (!tier)
+            return {
+                success: false,
+                diagnostics: [{ code: "tile-selection-unclassified", tileRef: entry.ref, relatedRef: null, path: "$.catalog" }],
+            };
+        facts.push({
+            ref: entry.ref,
+            tier,
+            lifecycle: lifecycleByRef[entry.ref],
+        });
+    }
+    return { success: true, data: { catalog: loaded.data, facts } };
+}
+/** Bundled product entry point from candidate offer through hard validation. */
+export function prepareBatch2TileSelection(request, lifecycleByRef) {
+    const surface = loadBatch2TileSelectionSurface(lifecycleByRef);
+    if (!surface.success)
+        return surface;
+    return prepareTileSelection(surface.data.catalog, request, surface.data.facts);
+}
+/** Optional Jev advisory over the same checked bundled Tile selection surface. */
+export async function prepareBatch2TileSelectionWithJevV1(request, lifecycleByRef, jev) {
+    const surface = loadBatch2TileSelectionSurface(lifecycleByRef);
+    if (!surface.success)
+        return surface;
+    return adviseTileSelectionWithJevV1({
+        catalog: surface.data.catalog,
+        request,
+        facts: surface.data.facts,
+        jev,
+    });
+}
+export function decideBatch2TileSelection(request, decision, lifecycleByRef) {
+    const surface = loadBatch2TileSelectionSurface(lifecycleByRef);
+    if (!surface.success)
+        return surface;
+    return decideTileSelection(surface.data.catalog, request, surface.data.facts, decision);
+}
+export function replayBatch2TileSelectionDecision(request, decision, lifecycleByRef) {
+    const surface = loadBatch2TileSelectionSurface(lifecycleByRef);
+    if (!surface.success)
+        return surface;
+    return replayTileSelectionDecision(surface.data.catalog, request, surface.data.facts, decision);
+}
+export const TILE_SELECTION_AUTHORIZATION_SCOPE_PREFIX = "pactile-tile-selection/v1:";
+const taskKernelCompat = taskKernelApi;
+const DEFAULT_TILE_SELECTION_POLICY = {
+    filesystem: "read",
+    process: "none",
+    network: "forbidden",
+    credentials: "forbidden",
+    privacy: "local-only",
+    egressDestinations: [],
+    telemetry: "local-only",
+    cost: "low",
+};
+function safeDefaultTaskAuthority() {
+    const body = {
+        policyCeiling: DEFAULT_TILE_SELECTION_POLICY,
+        capabilities: [],
+        providerFacts: [],
+    };
+    return {
+        ...body,
+        fact: {
+            source: "safe-default",
+            assurance: "no-grant",
+            fingerprint: fingerprintPactileContractV1(body),
+        },
+    };
+}
+function parseTaskSelectionGrant(scope, approved, catalog, facts) {
+    const fallback = safeDefaultTaskAuthority();
+    if (!approved ||
+        typeof scope !== "string" ||
+        !scope.startsWith(TILE_SELECTION_AUTHORIZATION_SCOPE_PREFIX))
+        return fallback;
+    try {
+        const serialized = scope.slice(TILE_SELECTION_AUTHORIZATION_SCOPE_PREFIX.length);
+        const parsed = JSON.parse(serialized);
+        if (!isRecord(parsed) ||
+            parsed.schemaVersion !== 1 ||
+            Object.keys(parsed).some((key) => !["schemaVersion", "policyCeiling", "capabilities", "providerFacts"].includes(key)) ||
+            canonicalizePactileJsonV1(parsed) !== serialized)
+            return fallback;
+        const candidate = normalizeTileSelectionReplayInput(catalog, {
+            intent: "exact",
+            requiredOutputs: ["context.pack"],
+            policyCeiling: parsed.policyCeiling,
+            capabilities: parsed.capabilities,
+            providerFacts: parsed.providerFacts,
+        }, facts);
+        if (!candidate.success)
+            return fallback;
+        const request = candidate.data.request;
+        const body = {
+            policyCeiling: request.policyCeiling,
+            capabilities: request.capabilities,
+            providerFacts: request.providerFacts ?? [],
+        };
+        return {
+            ...body,
+            fact: {
+                source: "task-kernel-approval-snapshot",
+                assurance: "recorded-user-assertion",
+                fingerprint: fingerprintPactileContractV1({ source: "task-kernel-approval-snapshot", body }),
+            },
+        };
+    }
+    catch {
+        return fallback;
+    }
+}
+function intersectRequestedCapabilities(requested, granted) {
+    const grantById = new Map(granted.map((fact) => [fact.id, fact]));
+    return requested.flatMap((fact) => {
+        const authorized = grantById.get(fact.id);
+        if (!authorized)
+            return [];
+        const requestedRank = ASSURANCE_LEVELS_V1.indexOf(fact.assurance);
+        const authorizedRank = ASSURANCE_LEVELS_V1.indexOf(authorized.assurance);
+        return [{
+                id: fact.id,
+                assurance: ASSURANCE_LEVELS_V1[Math.min(requestedRank, authorizedRank)],
+            }];
+    });
+}
+function intersectRequestedProviders(requested, granted) {
+    const grantedFacts = new Map(granted.map((fact) => [fingerprintPactileContractV1(fact), fact]));
+    return requested.flatMap((fact) => {
+        const exactGrant = grantedFacts.get(fingerprintPactileContractV1(fact));
+        return exactGrant ? [exactGrant] : [];
+    });
+}
+function applyTaskSelectionAuthority(surface, request) {
+    const normalized = normalizeTileSelectionReplayInput(surface.catalog, request, surface.facts);
+    if (!normalized.success)
+        return normalized;
+    return {
+        success: true,
+        data: {
+            ...normalized.data.request,
+            policyCeiling: intersectTilePolicies(normalized.data.request.policyCeiling, surface.authority.policyCeiling),
+            capabilities: intersectRequestedCapabilities(normalized.data.request.capabilities, surface.authority.capabilities),
+            providerFacts: intersectRequestedProviders(normalized.data.request.providerFacts ?? [], surface.authority.providerFacts),
+            taskLifecycle: surface.taskLifecycle,
+        },
+    };
+}
+function taskLifecycleFailure(reasonCode, taskLifecycle = null) {
+    return {
+        success: false,
+        diagnostics: [{ code: reasonCode, tileRef: null, relatedRef: null, path: "$.taskLifecycle" }],
+        receipt: createTileSelectionLifecycleFailureReceipt(reasonCode, taskLifecycle),
+    };
+}
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function readStringList(value, maximum) {
+    if (!Array.isArray(value) ||
+        value.length > maximum ||
+        value.some((item) => typeof item !== "string"))
+        return null;
+    return [...new Set(value)].sort();
+}
+function stableFilesystemPath(value) {
+    const resolved = fs.realpathSync.native(path.resolve(value)).replaceAll("\\", "/");
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function selectedTaskProjectFingerprint(root) {
+    return fingerprintPactileContractV1({
+        schemaVersion: 1,
+        kind: "pactile.tile-selection.project-scope",
+        root: stableFilesystemPath(root),
+    });
+}
+function selectedTaskScopeFingerprint(projectFingerprint, taskDir) {
+    return fingerprintPactileContractV1({
+        schemaVersion: 1,
+        kind: "pactile.tile-selection.task-scope",
+        projectFingerprint,
+        taskDir: stableFilesystemPath(taskDir),
+    });
+}
+function legacyApprovalScope(root, taskReference, taskId, phase, extras) {
+    const value = extras?.execution_approval;
+    if (!isRecord(value))
+        return { scope: null, approved: false };
+    const structurallyApproved = phase === "execute" &&
+        value.transition === "start-execution" &&
+        value.approved_by === "user" &&
+        value.task_id === taskId &&
+        typeof value.scope === "string";
+    if (!structurallyApproved)
+        return { scope: typeof value.scope === "string" ? value.scope : null, approved: false };
+    try {
+        approvedExecuteTask(root, taskReference);
+        return { scope: value.scope, approved: true };
+    }
+    catch {
+        return { scope: value.scope, approved: false };
+    }
+}
+function readSelectedTaskKernelFacts(root, taskDir, taskReference) {
+    if (taskKernelCompat.readTaskKernel && taskKernelCompat.projectTaskKernelLifecycle) {
+        const document = taskKernelCompat.readTaskKernel({ root, taskDir, cwd: root });
+        if (!isRecord(document))
+            throw new Error("kernel-read-failed");
+        if (document.kind === "task-kernel-v2") {
+            const projection = taskKernelCompat.projectTaskKernelLifecycle(document.kernel);
+            const approved = projection.phase === "execute" &&
+                (projection.condition === "ready" || projection.condition === "active") &&
+                projection.outcome === null &&
+                projection.approvalSnapshot.recorded &&
+                projection.approvalSnapshot.runId !== null &&
+                projection.approvalSnapshot.runId === projection.gateSnapshot.runStart.activeRunId &&
+                projection.approvalSnapshot.approvedBy === "user" &&
+                projection.gateSnapshot.runStart.phaseAllowsRun;
+            return {
+                taskId: projection.taskId,
+                revision: projection.revision,
+                phase: projection.phase,
+                condition: projection.condition,
+                outcome: projection.outcome,
+                extras: null,
+                approvalScope: projection.approvalSnapshot.scope,
+                executeApproved: approved,
+                hasTaskKernelV2: true,
+                activeRunId: projection.gateSnapshot.runStart.activeRunId,
+                approvalRunId: projection.approvalSnapshot.runId,
+            };
+        }
+        if (document.kind === "legacy-task-kernel-v1" && isRecord(document.kernel) && isRecord(document.kernel.kernel)) {
+            const kernel = document.kernel.kernel;
+            const extras = kernel.projection?.extras && isRecord(kernel.projection.extras)
+                ? kernel.projection.extras
+                : null;
+            const approval = legacyApprovalScope(root, taskReference, kernel.identity.taskId, kernel.phase, extras);
+            return {
+                taskId: kernel.identity.taskId,
+                revision: kernel.revision,
+                phase: kernel.phase,
+                condition: kernel.condition,
+                outcome: kernel.outcome,
+                extras,
+                approvalScope: approval.scope,
+                executeApproved: approval.approved,
+                hasTaskKernelV2: false,
+                activeRunId: null,
+                approvalRunId: null,
+            };
+        }
+        throw new Error("kernel-kind-unsupported");
+    }
+    const kernel = taskKernelCompat.readKernel({ taskDir, cwd: root }).kernel;
+    const extras = kernel.projection?.extras && isRecord(kernel.projection.extras)
+        ? kernel.projection.extras
+        : null;
+    const approval = legacyApprovalScope(root, taskReference, kernel.identity.taskId, kernel.phase, extras);
+    return {
+        taskId: kernel.identity.taskId,
+        revision: kernel.revision,
+        phase: kernel.phase,
+        condition: kernel.condition,
+        outcome: kernel.outcome,
+        extras,
+        approvalScope: approval.scope,
+        executeApproved: approval.approved,
+        hasTaskKernelV2: false,
+        activeRunId: null,
+        approvalRunId: null,
+    };
+}
+/** Read the currently selected Task and derive explicit Tile activation facts from Kernel state. */
+function loadSelectedTaskTileSelectionSurface(root, env) {
+    let selected;
+    try {
+        selected = resolveSelectedTask(root, env);
+    }
+    catch {
+        return taskLifecycleFailure("tile-selection-task-read-failed");
+    }
+    if (!selected.taskPath)
+        return taskLifecycleFailure("tile-selection-no-current-task");
+    if (selected.stale)
+        return taskLifecycleFailure("tile-selection-task-stale");
+    let taskDir;
+    let kernelFacts;
+    try {
+        taskDir = resolveTaskDir(root, selected.taskPath);
+        kernelFacts = readSelectedTaskKernelFacts(root, taskDir, selected.taskPath);
+    }
+    catch {
+        return taskLifecycleFailure("tile-selection-task-read-failed");
+    }
+    let projectFingerprint;
+    let scopeFingerprint;
+    try {
+        projectFingerprint = selectedTaskProjectFingerprint(root);
+        scopeFingerprint = selectedTaskScopeFingerprint(projectFingerprint, taskDir);
+    }
+    catch {
+        return taskLifecycleFailure("tile-selection-task-read-failed");
+    }
+    const taskLifecycle = {
+        taskId: kernelFacts.taskId,
+        projectFingerprint,
+        scopeFingerprint,
+        selectionGrant: safeDefaultTaskAuthority().fact,
+        revision: kernelFacts.revision,
+        phase: kernelFacts.phase,
+        condition: kernelFacts.condition,
+        outcome: kernelFacts.outcome,
+    };
+    const extras = kernelFacts.extras;
+    let baselineActive;
+    let registered;
+    let ondemandActive;
+    let degraded;
+    if (kernelFacts.hasTaskKernelV2) {
+        baselineActive = [...BASELINE_TILE_IDS];
+        registered = [...ONDEMAND_TILE_IDS];
+        ondemandActive = [];
+        degraded = [];
+    }
+    else {
+        if (!extras)
+            return taskLifecycleFailure("tile-selection-task-lifecycle-missing", taskLifecycle);
+        const baselineBlock = extras.baseline_modules;
+        const ondemandBlock = extras.ondemand_modules;
+        if (!isRecord(baselineBlock) || !isRecord(ondemandBlock))
+            return taskLifecycleFailure("tile-selection-task-lifecycle-missing", taskLifecycle);
+        const parsedBaselineActive = readStringList(baselineBlock.active, BASELINE_TILE_IDS.length);
+        const parsedRegistered = readStringList(ondemandBlock.registered, ONDEMAND_TILE_IDS.length);
+        const parsedOndemandActive = readStringList(ondemandBlock.active, ONDEMAND_TILE_IDS.length);
+        const parsedDegraded = readStringList(ondemandBlock.degraded, ONDEMAND_TILE_IDS.length);
+        if (!parsedBaselineActive || !parsedRegistered || !parsedOndemandActive || !parsedDegraded)
+            return taskLifecycleFailure("tile-selection-task-lifecycle-missing", taskLifecycle);
+        baselineActive = parsedBaselineActive;
+        registered = parsedRegistered;
+        ondemandActive = parsedOndemandActive;
+        degraded = parsedDegraded;
+    }
+    const baselineIds = new Set(BASELINE_TILE_IDS);
+    const knownOnDemand = new Set(ONDEMAND_TILE_IDS);
+    if (baselineActive.some((id) => !baselineIds.has(id)) ||
+        registered.some((id) => !knownOnDemand.has(id)) ||
+        ondemandActive.some((id) => !knownOnDemand.has(id) || !registered.includes(id)) ||
+        degraded.some((id) => !knownOnDemand.has(id) || !registered.includes(id)))
+        return taskLifecycleFailure("tile-selection-task-lifecycle-invalid", taskLifecycle);
+    const catalog = loadBatch2TileCatalog();
+    if (!catalog.success)
+        return catalog;
+    const degradedSet = new Set(degraded);
+    const registeredSet = new Set(registered);
+    const activeOnDemandSet = new Set(ondemandActive);
+    const activeBaselineSet = new Set(baselineActive);
+    const lifecycleByRef = {};
+    const baseline = new Set(BASELINE_TILE_IDS);
+    const ondemand = new Set(ONDEMAND_TILE_IDS);
+    for (const entry of catalog.data.entries) {
+        const id = entry.manifest.identity.id;
+        const tier = baseline.has(id)
+            ? "baseline"
+            : ondemand.has(id)
+                ? "on-demand"
+                : null;
+        if (!tier)
+            return {
+                success: false,
+                diagnostics: [{ code: "tile-selection-unclassified", tileRef: entry.ref, relatedRef: null, path: "$.catalog" }],
+            };
+        lifecycleByRef[entry.ref] = tier === "baseline"
+            ? (activeBaselineSet.has(id) ? "active" : "disabled")
+            : !registeredSet.has(id)
+                ? "retired"
+                : degradedSet.has(id)
+                    ? "degraded"
+                    : activeOnDemandSet.has(id)
+                        ? "active"
+                        : "registered";
+    }
+    const surface = loadBatch2TileSelectionSurface(lifecycleByRef);
+    if (!surface.success)
+        return surface;
+    const authority = parseTaskSelectionGrant(kernelFacts.approvalScope, kernelFacts.executeApproved, surface.data.catalog, surface.data.facts);
+    const lifecycleWithGrant = {
+        ...taskLifecycle,
+        selectionGrant: authority.fact,
+    };
+    return {
+        success: true,
+        data: {
+            ...surface.data,
+            taskLifecycle: lifecycleWithGrant,
+            authority,
+            hasTaskKernelV2: kernelFacts.hasTaskKernelV2,
+            activeRunId: kernelFacts.activeRunId,
+            approvalRunId: kernelFacts.approvalRunId,
+        },
+    };
+}
+function trustedSessionJevRunIdentity(surface) {
+    if (!surface.hasTaskKernelV2 ||
+        typeof surface.activeRunId !== "string" ||
+        surface.activeRunId.length === 0 ||
+        typeof surface.approvalRunId !== "string" ||
+        surface.approvalRunId.length === 0)
+        return null;
+    return {
+        activeRunId: surface.activeRunId,
+        approvalRunId: surface.approvalRunId,
+    };
+}
+/** Current-task product entry point; missing or unreadable Kernel facts fail closed with a receipt. */
+export function prepareSelectedTaskBatch2TileSelection(root, request, env = process.env) {
+    const surface = loadSelectedTaskTileSelectionSurface(root, env);
+    if (!surface.success)
+        return surface;
+    const effective = applyTaskSelectionAuthority(surface.data, request);
+    if (!effective.success)
+        return effective;
+    return prepareTileSelection(surface.data.catalog, effective.data, surface.data.facts);
+}
+function applySelectedTaskAgentTileProfile(surface) {
+    const base = taskTileSelectionRequest(surface.taskLifecycle.phase);
+    const authority = surface.authority;
+    const request = authority.fact.source === "task-kernel-approval-snapshot"
+        ? {
+            ...base,
+            policyCeiling: authority.policyCeiling,
+            capabilities: authority.capabilities,
+            providerFacts: authority.providerFacts,
+        }
+        : base;
+    return applyTaskSelectionAuthority(surface, request);
+}
+/** Agent session profile: read-only default, widened only by a recorded active Run grant. */
+export function prepareSelectedTaskAgentTileSelection(root, expectedLifecycle, env = process.env) {
+    const surface = loadSelectedTaskTileSelectionSurface(root, env);
+    if (!surface.success)
+        return surface;
+    // Session context is compiled from a Kernel read immediately before this
+    // call. If the selection, phase, or revision changed in between, avoid
+    // mixing facts from two Tasks or Kernel snapshots.
+    if (expectedLifecycle && (surface.data.taskLifecycle.taskId !== expectedLifecycle.taskId ||
+        surface.data.taskLifecycle.phase !== expectedLifecycle.phase ||
+        surface.data.taskLifecycle.revision !== expectedLifecycle.revision ||
+        (expectedLifecycle.activeRunId !== undefined &&
+            surface.data.activeRunId !== expectedLifecycle.activeRunId) ||
+        (expectedLifecycle.approvalRunId !== undefined &&
+            surface.data.approvalRunId !== expectedLifecycle.approvalRunId)))
+        return taskLifecycleFailure("tile-selection-task-read-failed", surface.data.taskLifecycle);
+    const effective = applySelectedTaskAgentTileProfile(surface.data);
+    if (!effective.success)
+        return effective;
+    return prepareTileSelection(surface.data.catalog, effective.data, surface.data.facts);
+}
+/** Optional Jev advice after rebuilding the current Kernel-bound Agent profile. */
+export async function prepareSelectedTaskAgentTileSelectionWithJevV1(root, jev, expectedLifecycle, env = process.env) {
+    const surface = loadSelectedTaskTileSelectionSurface(root, env);
+    if (!surface.success)
+        return surface;
+    if (expectedLifecycle && (surface.data.taskLifecycle.taskId !== expectedLifecycle.taskId ||
+        surface.data.taskLifecycle.phase !== expectedLifecycle.phase ||
+        surface.data.taskLifecycle.revision !== expectedLifecycle.revision ||
+        (expectedLifecycle.activeRunId !== undefined &&
+            surface.data.activeRunId !== expectedLifecycle.activeRunId) ||
+        (expectedLifecycle.approvalRunId !== undefined &&
+            surface.data.approvalRunId !== expectedLifecycle.approvalRunId)))
+        return taskLifecycleFailure("tile-selection-task-read-failed", surface.data.taskLifecycle);
+    if (jev && !trustedSessionJevRunIdentity(surface.data))
+        return taskLifecycleFailure("tile-selection-task-read-failed", surface.data.taskLifecycle);
+    const effective = applySelectedTaskAgentTileProfile(surface.data);
+    if (!effective.success)
+        return effective;
+    return adviseTileSelectionWithJevV1({
+        catalog: surface.data.catalog,
+        request: effective.data,
+        facts: surface.data.facts,
+        jev: jev
+            ? {
+                ...jev,
+                projectEgressPolicy: resolveJevProjectEgressPolicyV1(root),
+            }
+            : undefined,
+    });
+}
+/** Rebuild the current Agent profile from Kernel facts, then recompile a session offer decision. */
+export function decideSelectedTaskAgentTileSelection(root, decision, env = process.env, sessionJevAdviceFingerprint) {
+    const surface = loadSelectedTaskTileSelectionSurface(root, env);
+    if (!surface.success)
+        return surface;
+    const effective = applySelectedTaskAgentTileProfile(surface.data);
+    if (!effective.success)
+        return effective;
+    const decisionRunIdentity = sessionJevAdviceFingerprint !== undefined
+        ? trustedSessionJevRunIdentity(surface.data)
+        : null;
+    if (sessionJevAdviceFingerprint !== undefined && !decisionRunIdentity)
+        return {
+            success: false,
+            diagnostics: [{ code: "tile-selection-session-jev-advice-stale", tileRef: null, relatedRef: null, path: "$.sessionJev" }],
+        };
+    if (sessionJevAdviceFingerprint !== undefined) {
+        const currentOffer = prepareTileSelection(surface.data.catalog, effective.data, surface.data.facts);
+        if (!currentOffer.success || currentOffer.data.offer.fingerprint !== decision.offerFingerprint)
+            return {
+                success: false,
+                diagnostics: [{ code: "tile-selection-session-jev-advice-stale", tileRef: null, relatedRef: null, path: "$.sessionJev" }],
+            };
+    }
+    const result = decideTileSelection(surface.data.catalog, effective.data, surface.data.facts, decision);
+    if (!result.success)
+        return result;
+    if (sessionJevAdviceFingerprint !== undefined) {
+        const latestSurface = loadSelectedTaskTileSelectionSurface(root, env);
+        if (!latestSurface.success)
+            return { success: false, diagnostics: latestSurface.diagnostics };
+        const latestRunIdentity = trustedSessionJevRunIdentity(latestSurface.data);
+        if (!latestRunIdentity ||
+            latestRunIdentity.activeRunId !== decisionRunIdentity?.activeRunId ||
+            latestRunIdentity.approvalRunId !== decisionRunIdentity?.approvalRunId)
+            return {
+                success: false,
+                diagnostics: [{ code: "tile-selection-session-jev-advice-stale", tileRef: null, relatedRef: null, path: "$.sessionJev" }],
+            };
+        const latestEffective = applySelectedTaskAgentTileProfile(latestSurface.data);
+        if (!latestEffective.success)
+            return { success: false, diagnostics: latestEffective.diagnostics };
+        const latestOffer = prepareTileSelection(latestSurface.data.catalog, latestEffective.data, latestSurface.data.facts);
+        if (!latestOffer.success || latestOffer.data.offer.fingerprint !== result.data.offerFingerprint)
+            return {
+                success: false,
+                diagnostics: [{ code: "tile-selection-session-jev-advice-stale", tileRef: null, relatedRef: null, path: "$.sessionJev" }],
+            };
+    }
+    const stored = writeTileSelectionSnapshot(root, surface.data.catalog, effective.data, surface.data.facts, decision, result.data, sessionJevAdviceFingerprint, decisionRunIdentity ?? undefined);
+    if (!stored.success)
+        return {
+            success: false,
+            diagnostics: stored.diagnostics,
+            receipt: result.data,
+        };
+    return { success: true, data: result.data, snapshot: stored.data };
+}
+export function decideSelectedTaskBatch2TileSelection(root, request, decision, env = process.env) {
+    const surface = loadSelectedTaskTileSelectionSurface(root, env);
+    if (!surface.success)
+        return surface;
+    const effective = applyTaskSelectionAuthority(surface.data, request);
+    if (!effective.success)
+        return effective;
+    const result = decideTileSelection(surface.data.catalog, effective.data, surface.data.facts, decision);
+    if (!result.success)
+        return result;
+    const stored = writeTileSelectionSnapshot(root, surface.data.catalog, effective.data, surface.data.facts, decision, result.data);
+    if (!stored.success)
+        return {
+            success: false,
+            diagnostics: stored.diagnostics,
+            receipt: result.data,
+        };
+    return { success: true, data: result.data, snapshot: stored.data };
+}
+export function replaySelectedTaskBatch2TileSelectionDecision(root, request, decision, env = process.env) {
+    const surface = loadSelectedTaskTileSelectionSurface(root, env);
+    if (!surface.success)
+        return surface;
+    const effective = applyTaskSelectionAuthority(surface.data, request);
+    if (!effective.success)
+        return effective;
+    return replayTileSelectionDecision(surface.data.catalog, effective.data, surface.data.facts, decision);
+}
+/** Replay a previously stored Task decision without reading mutable Task state. */
+export function replayStoredSelectedTaskBatch2TileSelectionDecision(root, snapshotFingerprint) {
+    const catalog = loadBatch2TileCatalog();
+    if (!catalog.success)
+        return catalog;
+    return replayTileSelectionSnapshot(root, snapshotFingerprint, catalog.data);
+}
 function tileFailure(code, platform, adapterId, detail) {
     return {
         status: "review",
@@ -149,17 +768,10 @@ export function composeBatch2Plan(request) {
                 { code: "shared-review", detail: shared.diagnostics[0] },
             ],
         };
-    let adapter;
-    if (request.platform === "cursor")
-        adapter = buildCursorProjectionPlan({
-            ...request.adapter,
-            shared: shared.inputs,
-        });
-    else
-        adapter = buildCodexProjectionPlan({
-            ...request.adapter,
-            shared: shared.inputs,
-        });
+    const adapter = buildCodexProjectionPlan({
+        ...request.adapter,
+        shared: shared.inputs,
+    });
     if (adapter.status === "ready")
         return {
             status: "ready",