@sema-agent/server 7.137.0 → 7.139.0

package/dist/http/execution-context.js

@@ -0,0 +1,330 @@
+import { HttpError, createCodedHttpError, ssoVerifiedScope } from "../security.js";
+import { gatedPrincipal } from "./principal-gate.js";
+import { DEVICE_ERROR_CODES, assertDeviceIdShape } from "../device-store.js";
+import { buildDeviceRejection } from "../device-enrollment.js";
+import { sameOccupant } from "../execution-placement.js";
+import { deployedExecutionLanes } from "../execution-lane-caps.js";
+import { gateExecutionLane } from "../runtime-caps-resolver.js";
+import { releaseClaimedRun } from "./claimed-run.js";
+import { refusalBody } from "./refusal-body.js";
+export async function resolveExecutionContext(deps, entry) {
+    const lanes = deployedExecutionLanes(deps.config);
+    switch (entry.kind) {
+        case "service":
+            return { kind: "service", lane: lanes[0], placement: "absent" };
+        case "fresh":
+        case "continuation": {
+            const seat = deps.sessionStorage?.executionPlacement;
+            const reading = seat === undefined ? undefined : await readRow(seat, entry.root, entry.kind === "fresh" ? entry.judged : undefined);
+            const { lane, placement } = laneOf(entry.root, reading?.cell ?? { role: "absent" }, lanes);
+            gateExecutionLane(await deps.executionRuling?.(entry.principal), lane, deps.logger);
+            const ctx = { kind: entry.kind, root: entry.root, occupant: reading?.occupant, placement, lane };
+            if (entry.kind === "continuation")
+                return ctx;
+            const device = await admitDevicePlacement(deps, entry, lane, seat, reading);
+            return device === undefined ? ctx : { ...ctx, device };
+        }
+        default: {
+            const unhandled = entry;
+            throw new Error(`resolveExecutionContext: unhandled entry ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+async function readRow(seat, root, judged) {
+    const reading = await seat.read(root);
+    if (reading === undefined || (judged !== undefined && !sameOccupant(judged, reading.occupant)))
+        throw rootSessionGoneError();
+    if (reading.cell.role === "forking") {
+        throw createCodedHttpError(409, "conflict.fork_in_progress", "this session is the target of a fork that has not finished copying — retry that fork with the same forkId and forkNonce, or delete the session; nothing was started");
+    }
+    return reading;
+}
+function laneOf(root, cell, lanes) {
+    switch (cell.role) {
+        case "absent":
+            return { lane: lanes[0], placement: "absent" };
+        case "writer":
+            if (!lanes.includes(cell.lane)) {
+                throw createCodedHttpError(409, "execution_lane.not_served", "this session is placed where this deployment no longer runs work (see boundLane) — nothing was started", { boundLane: cell.lane });
+            }
+            return { lane: cell.lane, placement: "writer" };
+        case "mirror":
+            throw sessionMirrorError(root);
+        case "forking":
+            throw new Error(`resolveExecutionContext: session ${root} reads as forking after the read step refused it`);
+        default: {
+            const unknownRole = cell;
+            throw new Error(`resolveExecutionContext: no lane for ${JSON.stringify(unknownRole)}`);
+        }
+    }
+}
+function sessionMirrorError(root) {
+    const answer = sessionMirrorAnswer(root);
+    return createCodedHttpError(answer.status, answer.body.errorCode, answer.body.error, { forkPath: forkPathOf(root) });
+}
+export function forkPathOf(root) {
+    return `/v1/sessions/${encodeURIComponent(root)}/fork`;
+}
+function sessionMirrorAnswer(root) {
+    return {
+        status: 409,
+        body: refusalBody({
+            errorCode: "conflict.session_mirror",
+            message: "this session is a read-only mirror of a session whose writer is elsewhere — it cannot run here; fork it (forkPath) to continue here; nothing was started",
+            facts: { forkPath: forkPathOf(root) },
+        }),
+    };
+}
+function rootSessionGoneError() {
+    const absent = rootSessionAbsentAnswer();
+    return createCodedHttpError(absent.status, absent.body.errorCode, absent.body.error);
+}
+export function isRootSessionGoneError(err) {
+    return err instanceof HttpError && err.code === rootSessionAbsentAnswer().body.errorCode;
+}
+export function deviceOwnerDomainOf(req, config) {
+    const subject = gatedPrincipal(req, config);
+    if (subject === undefined)
+        return undefined;
+    const tenant = ssoVerifiedScope(req);
+    if (tenant === undefined)
+        return undefined;
+    return { tenant, subject };
+}
+function asHttpError(rej) {
+    return createCodedHttpError(rej.status, rej.code, rej.message);
+}
+function registryUnavailable() {
+    return buildDeviceRejection(DEVICE_ERROR_CODES.NOT_BOUND, "the device binding for this session could not be resolved (the device registry is unavailable) — refusing rather than running on an unverified device");
+}
+async function admitDevicePlacement(deps, entry, lane, seat, reading) {
+    const requested = entry.deviceId;
+    if (lane !== "device") {
+        if (requested !== undefined) {
+            throw createCodedHttpError(400, "request.precondition_unmet", "deviceId is only accepted on a deployment that executes on the user's own device (REMOTE_EXEC=device) — this deployment does not, so binding this session to a device id would be a declaration that never took effect");
+        }
+        return undefined;
+    }
+    if (!deps.deviceStore || !deps.deviceEnrollment || seat === undefined || reading === undefined) {
+        throw createCodedHttpError(501, "capability.device_lane_required", "device execution is selected for this deployment but its stores are not wired on this replica — refusing to admit a submit that would execute nowhere");
+    }
+    if (entry.req === undefined) {
+        throw createCodedHttpError(403, "auth.forbidden", "device placement needs a verified caller domain and this leg carries no request context");
+    }
+    const owner = deviceOwnerDomainOf(entry.req, deps.config);
+    if (owner === undefined) {
+        throw createCodedHttpError(403, "auth.forbidden", "device placement needs a caller domain: this credential carries no verified tenant scope claim (registry auth-bridge JWT `scope`) — connect through the registry auth bridge");
+    }
+    if (requested !== undefined) {
+        if (typeof requested !== "string") {
+            throw createCodedHttpError(400, "request.field_invalid", "deviceId must be a string (the device id returned by POST /v1/devices/enroll)");
+        }
+        try {
+            assertDeviceIdShape(requested);
+        }
+        catch {
+            throw createCodedHttpError(400, "request.field_invalid", "deviceId is not a valid device id (byte-exact key: non-empty, no control characters or surrounding whitespace, at most 64 bytes)");
+        }
+    }
+    const requestedDeviceId = requested;
+    let admitted;
+    try {
+        admitted = await deps.deviceEnrollment.admitSession({ rootSessionId: entry.root, placement: reading, requester: owner, ...(requestedDeviceId === undefined ? {} : { requestedDeviceId }) });
+    }
+    catch {
+        throw asHttpError(registryUnavailable());
+    }
+    if (admitted.ok)
+        return { rootSessionId: entry.root, occupant: reading.occupant, owner, admittedDeviceId: admitted.value.deviceId, firstBind: false };
+    if (admitted.reject.code !== DEVICE_ERROR_CODES.NOT_BOUND || requestedDeviceId === undefined)
+        throw asHttpError(admitted.reject);
+    let view;
+    try {
+        view = await deps.deviceStore.readDeviceForAdmission(requestedDeviceId, owner);
+    }
+    catch {
+        throw asHttpError(registryUnavailable());
+    }
+    if (!view)
+        throw asHttpError(buildDeviceRejection(DEVICE_ERROR_CODES.NOT_FOUND, "device not found"));
+    if (view.row.status === "revoked")
+        throw asHttpError(buildDeviceRejection(DEVICE_ERROR_CODES.REVOKED, "device has been revoked"));
+    if (!view.online)
+        throw asHttpError(buildDeviceRejection(DEVICE_ERROR_CODES.OFFLINE, "device is not connected"));
+    return { rootSessionId: entry.root, occupant: reading.occupant, owner, admittedDeviceId: requestedDeviceId, firstBind: true };
+}
+export function stampSpecRoot(spec, ctx) {
+    const named = spec.sessionId;
+    if (named !== undefined && named !== ctx.root) {
+        throw createCodedHttpError(400, "request.precondition_unmet", "the deployment's spec resolver named a session other than the one this submission was authorized for — a submission's root session comes only from the authorizer, so resolveSpec must not set sessionId (read opts.execution.root instead)");
+    }
+    return { ...spec, sessionId: ctx.root };
+}
+export function rootSessionAbsentAnswer() {
+    return {
+        status: 404,
+        body: refusalBody({
+            errorCode: "resume.session_not_found",
+            message: "the session this run was to start on no longer exists (it was deleted after the request was admitted) — nothing was started",
+        }),
+    };
+}
+export function placementWriteDeadlineMs(runStaleSec) {
+    const stale = typeof runStaleSec === "number" && Number.isFinite(runStaleSec) && runStaleSec > 0 ? runStaleSec : 120;
+    return Math.min(15_000, Math.max(1_000, Math.floor((stale * 1000) / 4)));
+}
+function deviceRefusal(rej) {
+    return { status: rej.status, body: devicePlacementErrorBody(rej) };
+}
+export function devicePlacementErrorBody(rej) {
+    return refusalBody({ errorCode: rej.code, message: rej.message });
+}
+function treeBoundAnswer(boundLane) {
+    return {
+        status: 409,
+        body: refusalBody({
+            errorCode: "execution_lane.tree_bound",
+            message: "this session is already placed elsewhere on this deployment (see boundLane) — this run cannot be placed somewhere else; nothing was started",
+            facts: { boundLane },
+        }),
+    };
+}
+export async function commitExecutionContext(deps, claim, ctx) {
+    const seat = deps.sessionStorage?.executionPlacement;
+    if (ctx.occupant === undefined || seat === undefined)
+        return null;
+    const occupant = ctx.occupant;
+    const release = (why) => releaseClaim(deps, claim, why);
+    const deadlineMs = placementWriteDeadlineMs(deps.config?.runStaleSec);
+    const withDeadline = async (work) => {
+        let timer;
+        try {
+            return await Promise.race([
+                work,
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => reject(new Error(`execution placement store call exceeded ${deadlineMs}ms`)), deadlineMs);
+                    timer.unref?.();
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    };
+    const goneAnswer = () => (claim.kind === "parked" ? claim.goneAnswer : rootSessionAbsentAnswer());
+    let refusal;
+    try {
+        refusal =
+            ctx.device !== undefined
+                ? await commitDevice(deps, seat, ctx.device, withDeadline, goneAnswer)
+                : ctx.placement === "absent"
+                    ? await commitPlace(seat, ctx, occupant, withDeadline, goneAnswer)
+                    : await reassertWriter(seat, ctx, occupant, withDeadline, goneAnswer);
+    }
+    catch (err) {
+        deps.logger?.warn("execution_placement_commit_failed", { root: ctx.root, lane: ctx.lane, placement: ctx.placement, deadlineMs, err: err instanceof Error ? err.message : String(err) });
+        await release(`execution placement could not be committed: ${err instanceof Error ? err.message : String(err)}`);
+        if (ctx.device !== undefined) {
+            refusal = deviceRefusal(registryUnavailable());
+            deps.metrics?.inc("execution_placement_rejects_total", { errorCode: refusal.body.errorCode });
+            return refusal;
+        }
+        throw err;
+    }
+    if (refusal === null)
+        return null;
+    deps.metrics?.inc("execution_placement_rejects_total", { errorCode: refusal.body.errorCode });
+    await release(`execution placement rejected: [${refusal.body.errorCode}] ${refusal.body.error}`);
+    return refusal;
+}
+async function releaseClaim(deps, claim, why) {
+    switch (claim.kind) {
+        case "run":
+            await releaseClaimedRun(claim.runStore, claim.taskId, why, (err, step) => {
+                deps.logger?.warn("execution_placement_run_release_failed", { taskId: claim.taskId, step, err: err instanceof Error ? err.message : String(err) });
+                deps.metrics?.inc("execution_placement_run_release_failed_total");
+            });
+            return;
+        case "parked":
+            await claim.rollback(why);
+            return;
+        default: {
+            const unhandled = claim;
+            throw new Error(`commitExecutionContext: unknown claim ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+async function commitPlace(seat, ctx, occupant, withDeadline, goneAnswer) {
+    if (ctx.lane === "device") {
+        return deviceRefusal(buildDeviceRejection(DEVICE_ERROR_CODES.NOT_BOUND, "this session has no device binding — nothing was started"));
+    }
+    return placeOutcomeAnswer(ctx.root, await withDeadline(seat.place(ctx.root, occupant, { role: "writer", lane: ctx.lane })), goneAnswer);
+}
+function placeOutcomeAnswer(root, outcome, goneAnswer) {
+    switch (outcome.outcome) {
+        case "placed":
+        case "same":
+            return null;
+        case "tree_bound":
+            return treeBoundAnswer(outcome.boundLane);
+        case "mirror":
+            return sessionMirrorAnswer(root);
+        case "gone":
+            return goneAnswer();
+        default: {
+            const unhandled = outcome;
+            throw new Error(`commitExecutionContext: no answer for ${JSON.stringify(unhandled)}`);
+        }
+    }
+}
+async function reassertWriter(seat, ctx, occupant, withDeadline, goneAnswer) {
+    const now = await withDeadline(seat.read(ctx.root));
+    if (now === undefined || !sameOccupant(now.occupant, occupant))
+        return goneAnswer();
+    const cell = now.cell;
+    switch (cell.role) {
+        case "writer":
+            return cell.lane === ctx.lane ? null : treeBoundAnswer(cell.lane);
+        case "mirror":
+            return sessionMirrorAnswer(ctx.root);
+        case "absent":
+        case "forking":
+            throw new Error(`commitExecutionContext: session ${ctx.root} was resolved as a writer and now reads as ${cell.role} for the same occupant`);
+        default: {
+            const unknownRole = cell;
+            throw new Error(`commitExecutionContext: no arm for ${JSON.stringify(unknownRole)}`);
+        }
+    }
+}
+async function commitDevice(deps, seat, intent, withDeadline, goneAnswer) {
+    const enrollment = deps.deviceEnrollment;
+    if (!enrollment) {
+        throw new Error("commitExecutionContext: a device placement intent was minted without a DeviceEnrollment — assembly bug (both are read from the same ServiceDeps)");
+    }
+    if (intent.firstBind) {
+        const bound = await withDeadline(enrollment.bindPlacement({ rootSessionId: intent.rootSessionId, occupant: intent.occupant, deviceId: intent.admittedDeviceId, requester: intent.owner }));
+        if (bound.ok)
+            return null;
+        if ("reject" in bound)
+            return deviceRefusal(bound.reject);
+        switch (bound.placement) {
+            case "gone":
+                return goneAnswer();
+            case "mirror":
+                return sessionMirrorAnswer(intent.rootSessionId);
+            case "tree_bound":
+                return treeBoundAnswer(bound.boundLane);
+            default: {
+                const unhandled = bound;
+                throw new Error(`commitExecutionContext: no answer for ${JSON.stringify(unhandled)}`);
+            }
+        }
+    }
+    const placement = await withDeadline(seat.read(intent.rootSessionId));
+    if (placement === undefined || !sameOccupant(placement.occupant, intent.occupant))
+        return goneAnswer();
+    const readmitted = await withDeadline(enrollment.admitSession({ rootSessionId: intent.rootSessionId, placement, requester: intent.owner, requestedDeviceId: intent.admittedDeviceId }));
+    return readmitted.ok ? null : deviceRefusal(readmitted.reject);
+}
+//# sourceMappingURL=execution-context.js.map

package/dist/http/memory-compliance-failure-reply.js

@@ -8,6 +8,9 @@ function sentCoreCode(res, coreCode, coreMessage, audience) {
         case "config.memory_erasure_request":
             sendError(res, 400, "config.memory_erasure_request", textFor(audience, coreMessage, "session memory erasure refused — the erasure request is not valid; correct it and resend"));
             return true;
+        case "config.memory_erasure_scope":
+            sendError(res, 400, "config.memory_erasure_scope", textFor(audience, coreMessage, "session memory erasure refused — the request reaches memory outside the scopes it may erase; nothing was erased"));
+            return true;
         case "memory.erasure_evidence_unavailable":
             sendError(res, 409, "memory.erasure_evidence_unavailable", textFor(audience, coreMessage, "session memory erasure refused — this deployment's memory store cannot produce erasure evidence; resend with allowUnevidenced: true to erase without evidence, or ask the operator"));
             return true;

package/dist/http/resume-legs.d.ts

@@ -18,7 +18,7 @@ import type { CheckpointStoreFull } from "../plugins/store-backend.js";
 import type { HostDecision } from "../host-decision.js";
 import { type GateSighting } from "../approval-gate-currency.js";
 import { type PlanApprovePermissionModeAfter } from "../task-settings.js";
-import type { RouteCtxBase, DriveResumeArgs, HostLegOutcome, PreparedPlanReview, ResumeLegOutcome, WorkflowDecisionDelivery } from "./route-ctx.js";
+import type { RouteCtxBase, DriveResumeArgs, PreparedPlanReview, ResumeLegOutcome, WorkflowDecisionDelivery } from "./route-ctx.js";
 import type { RunRegistry, RouteHelpers, RouteLegs } from "./route-ctx.js";
 import type { createRequestGuards } from "./request-guards.js";
 import type { FlatServiceDeps } from "./server.js";
@@ -59,12 +59,9 @@ export declare function createResumeLegs(ctx: {
     resumePreempted: (sessionId: string, req: IncomingMessage | undefined, acceptEarly?: boolean, decider?: {
         principal?: string;
         explicitOperator: boolean;
-    }) => Promise<{
-        status: number;
-        body: object;
-    }>;
-    startFreshHostTurn: (sessionId: string, objective: string, principal: string | undefined, req: IncomingMessage, workflowDecision: WorkflowDecisionDelivery, runId: string) => Promise<HostLegOutcome>;
-    resumeWake: (sessionId: string, message: string | undefined, caller: string | undefined, req: IncomingMessage | undefined, acceptEarly?: boolean, workflowDecision?: WorkflowDecisionDelivery, ownerLeaseAdmittedFor?: string) => Promise<HostLegOutcome>;
+    }) => Promise<ResumeLegOutcome>;
+    startFreshHostTurn: (sessionId: string, objective: string, principal: string | undefined, req: IncomingMessage, workflowDecision: WorkflowDecisionDelivery, runId: string) => Promise<ResumeLegOutcome>;
+    resumeWake: (sessionId: string, message: string | undefined, caller: string | undefined, req: IncomingMessage | undefined, acceptEarly?: boolean, workflowDecision?: WorkflowDecisionDelivery, ownerLeaseAdmittedFor?: string) => Promise<ResumeLegOutcome>;
     preparePlanReview: (sessionId: string, log?: {
         taskId?: string;
         principalPresent?: boolean;
@@ -81,9 +78,6 @@ export declare function createResumeLegs(ctx: {
         readonly ok: true;
         readonly prepared: PreparedPlanReview;
     }>;
-    drivePlanReview: (prepared: PreparedPlanReview, decision: "approve" | "edit" | "reject", editedPlan: string | undefined, reason: string | undefined, hostDecision: HostDecision, req: IncomingMessage | undefined, acceptEarly?: boolean, permissionModeAfter?: PlanApprovePermissionModeAfter) => Promise<{
-        status: number;
-        body: object;
-    }>;
+    drivePlanReview: (prepared: PreparedPlanReview, decision: "approve" | "edit" | "reject", editedPlan: string | undefined, reason: string | undefined, hostDecision: HostDecision, req: IncomingMessage | undefined, acceptEarly?: boolean, permissionModeAfter?: PlanApprovePermissionModeAfter) => Promise<ResumeLegOutcome>;
 };
 //# sourceMappingURL=resume-legs.d.ts.map