@opengeni/db 1.0.1 → 3.1.0-canary.0

package/dist/chunk-ZZ5LJEFX.js

@@ -0,0 +1,516 @@
+import {
+  withRlsContext
+} from "./chunk-SCPUJS53.js";
+import {
+  sandboxRetainedProcesses,
+  sessionBackgroundCommands,
+  sessions
+} from "./chunk-PR2WMLOQ.js";
+
+// src/session-background-commands.ts
+import { and, desc, eq, inArray, sql } from "drizzle-orm";
+function commandPreview(value) {
+  const normalized = value.replace(/\s+/g, " ").trim();
+  return Array.from(normalized).slice(0, 512).join("");
+}
+function mapCommand(row) {
+  return {
+    id: row.id,
+    workspaceId: row.workspaceId,
+    sessionId: row.sessionId,
+    provider: row.provider,
+    state: row.state,
+    commandPreview: row.commandPreview,
+    cancelRequestedAt: row.cancelRequestedAt?.toISOString() ?? null,
+    exitCode: row.exitCode ?? null,
+    settlementReason: row.settlementReason ?? null,
+    startedAt: row.startedAt.toISOString(),
+    settledAt: row.settledAt?.toISOString() ?? null,
+    updatedAt: row.updatedAt.toISOString()
+  };
+}
+async function backgroundCommandActivityForSessions(db, input) {
+  if (input.sessionIds.length === 0) return /* @__PURE__ */ new Map();
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.select({
+        sessionId: sessionBackgroundCommands.sessionId,
+        count: sql`count(*)::int`,
+        stoppingCount: sql`count(*) filter (where ${sessionBackgroundCommands.state} = 'stopping')::int`
+      }).from(sessionBackgroundCommands).where(
+        and(
+          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          inArray(sessionBackgroundCommands.sessionId, input.sessionIds),
+          inArray(sessionBackgroundCommands.state, ["running", "stopping"])
+        )
+      ).groupBy(sessionBackgroundCommands.sessionId);
+      return new Map(
+        rows.map((row) => [
+          row.sessionId,
+          {
+            state: Number(row.stoppingCount) > 0 ? "stopping" : "running",
+            count: Number(row.count)
+          }
+        ])
+      );
+    }
+  );
+}
+async function listSessionBackgroundCommands(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.select().from(sessionBackgroundCommands).where(
+        and(
+          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq(sessionBackgroundCommands.sessionId, input.sessionId)
+        )
+      ).orderBy(
+        desc(sessionBackgroundCommands.startedAt),
+        desc(sessionBackgroundCommands.id)
+      ).limit(1e3);
+      return rows.map(mapCommand);
+    }
+  );
+}
+async function insertManagedSessionBackgroundCommandInTransaction(db, input) {
+  const [process] = await db.select({
+    accountId: sandboxRetainedProcesses.accountId,
+    workspaceId: sandboxRetainedProcesses.workspaceId,
+    sessionId: sandboxRetainedProcesses.sessionId,
+    state: sandboxRetainedProcesses.state
+  }).from(sandboxRetainedProcesses).where(eq(sandboxRetainedProcesses.id, input.retainedProcessId)).for("update").limit(1);
+  if (!process || process.accountId !== input.accountId || process.workspaceId !== input.workspaceId || process.sessionId !== input.sessionId || process.state !== "active") {
+    throw new Error("Managed background command requires its exact active retained process");
+  }
+  const [row] = await db.insert(sessionBackgroundCommands).values({
+    id: input.commandId,
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    provider: "managed",
+    state: "running",
+    retainedProcessId: input.retainedProcessId,
+    commandPreview: commandPreview(input.command)
+  }).onConflictDoUpdate({
+    target: sessionBackgroundCommands.retainedProcessId,
+    targetWhere: sql`${sessionBackgroundCommands.retainedProcessId} is not null`,
+    set: { updatedAt: /* @__PURE__ */ new Date() }
+  }).returning();
+  if (!row) throw new Error("Managed background command adoption returned no row");
+  if (row.accountId !== input.accountId || row.workspaceId !== input.workspaceId || row.sessionId !== input.sessionId || row.provider !== "managed" || row.retainedProcessId !== input.retainedProcessId) {
+    throw new Error("Managed background command adoption conflicted with another identity");
+  }
+  return mapCommand(row);
+}
+async function insertConnectedMachineSessionBackgroundCommandInTransaction(db, input) {
+  const [row] = await db.insert(sessionBackgroundCommands).values({
+    id: input.commandId,
+    accountId: input.accountId,
+    workspaceId: input.workspaceId,
+    sessionId: input.sessionId,
+    provider: "connected_machine",
+    state: "running",
+    controlWorkspaceId: input.controlWorkspaceId,
+    enrollmentId: input.enrollmentId,
+    connectionInstanceId: input.connectionInstanceId,
+    opId: input.opId,
+    commandPreview: commandPreview(input.command)
+  }).onConflictDoUpdate({
+    target: [
+      sessionBackgroundCommands.controlWorkspaceId,
+      sessionBackgroundCommands.enrollmentId,
+      sessionBackgroundCommands.connectionInstanceId,
+      sessionBackgroundCommands.opId
+    ],
+    targetWhere: sql`${sessionBackgroundCommands.provider} = 'connected_machine'`,
+    set: { updatedAt: /* @__PURE__ */ new Date() }
+  }).returning();
+  if (!row) throw new Error("Connected Machine background command adoption returned no row");
+  if (row.accountId !== input.accountId || row.workspaceId !== input.workspaceId || row.sessionId !== input.sessionId || row.provider !== "connected_machine" || row.controlWorkspaceId !== input.controlWorkspaceId || row.enrollmentId !== input.enrollmentId || row.connectionInstanceId !== input.connectionInstanceId || row.opId !== input.opId) {
+    throw new Error(
+      "Connected Machine background command adoption conflicted with another identity"
+    );
+  }
+  return mapCommand(row);
+}
+async function claimConnectedMachineSessionBackgroundCommands(db, input) {
+  if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100) {
+    throw new Error("Connected command reconciliation limit must be between 1 and 100");
+  }
+  if (!Number.isSafeInteger(input.claimTtlMs) || input.claimTtlMs < 0 || input.claimTtlMs > 36e5) {
+    throw new Error("Connected command reconciliation claim TTL is invalid");
+  }
+  const rows = await db.execute(sql`
+    select account_id as "accountId",
+      workspace_id as "workspaceId",
+      session_id as "sessionId",
+      command_id as "commandId",
+      claim_id as "claimId",
+      command_state as "commandState",
+      control_workspace_id as "controlWorkspaceId",
+      enrollment_id as "enrollmentId",
+      connection_instance_id as "connectionInstanceId",
+      op_id as "opId",
+      reconcile_attempts as "reconcileAttempts",
+      reconcile_proof_outcome as "reconcileProofOutcome",
+      reconcile_proof_exit_code as "reconcileProofExitCode",
+      reconcile_proof_reason as "reconcileProofReason",
+      reconcile_proof_observed_at as "reconcileProofObservedAt"
+    from opengeni_private.claim_connected_machine_background_commands(
+      ${input.claimId}::uuid, ${input.limit}::integer, ${input.claimTtlMs}::bigint
+    )
+  `);
+  return rows.map((row) => {
+    if (row.commandState !== "running" && row.commandState !== "stopping") {
+      throw new Error(`Connected command claim returned invalid state ${row.commandState}`);
+    }
+    const proof = row.reconcileProofOutcome === null ? null : row.reconcileProofOutcome === "exited" || row.reconcileProofOutcome === "lost" ? {
+      outcome: row.reconcileProofOutcome,
+      exitCode: row.reconcileProofExitCode === null ? null : Number(row.reconcileProofExitCode),
+      reason: row.reconcileProofReason,
+      observedAt: row.reconcileProofObservedAt instanceof Date ? row.reconcileProofObservedAt : new Date(row.reconcileProofObservedAt)
+    } : (() => {
+      throw new Error(
+        `Connected command claim returned invalid proof ${row.reconcileProofOutcome}`
+      );
+    })();
+    return {
+      commandId: row.commandId,
+      accountId: row.accountId,
+      workspaceId: row.workspaceId,
+      sessionId: row.sessionId,
+      claimId: row.claimId,
+      state: row.commandState,
+      controlWorkspaceId: row.controlWorkspaceId,
+      enrollmentId: row.enrollmentId,
+      connectionInstanceId: row.connectionInstanceId,
+      opId: row.opId,
+      reconcileAttempts: Number(row.reconcileAttempts),
+      proof
+    };
+  });
+}
+function connectedClaimIdentityWhere(claim) {
+  return and(
+    eq(sessionBackgroundCommands.id, claim.commandId),
+    eq(sessionBackgroundCommands.accountId, claim.accountId),
+    eq(sessionBackgroundCommands.workspaceId, claim.workspaceId),
+    eq(sessionBackgroundCommands.sessionId, claim.sessionId),
+    eq(sessionBackgroundCommands.provider, "connected_machine"),
+    eq(sessionBackgroundCommands.controlWorkspaceId, claim.controlWorkspaceId),
+    eq(sessionBackgroundCommands.enrollmentId, claim.enrollmentId),
+    eq(sessionBackgroundCommands.connectionInstanceId, claim.connectionInstanceId),
+    eq(sessionBackgroundCommands.opId, claim.opId),
+    eq(sessionBackgroundCommands.reconcileClaimId, claim.claimId),
+    inArray(sessionBackgroundCommands.state, ["running", "stopping"])
+  );
+}
+async function recordConnectedMachineBackgroundCommandProof(db, input) {
+  const reason = input.proof.reason.trim().slice(0, 512);
+  if (!reason) throw new Error("Connected command proof reason must not be empty");
+  if (input.proof.outcome === "exited" && input.proof.exitCode === null) {
+    throw new Error("Connected command exit proof requires an exit code");
+  }
+  if (input.proof.outcome === "lost" && input.proof.exitCode !== null) {
+    throw new Error("Connected command loss proof cannot carry an exit code");
+  }
+  await withRlsContext(
+    db,
+    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
+    async (scopedDb) => {
+      const [current] = await scopedDb.select().from(sessionBackgroundCommands).where(connectedClaimIdentityWhere(input.claim)).for("update").limit(1);
+      if (!current) throw new Error("Connected command proof was fenced by newer lifecycle state");
+      if (current.reconcileProofOutcome !== null) {
+        const observedAt = current.reconcileProofObservedAt?.getTime() ?? null;
+        if (current.reconcileProofOutcome !== input.proof.outcome || current.reconcileProofExitCode !== input.proof.exitCode || current.reconcileProofReason !== reason || observedAt !== input.proof.observedAt.getTime()) {
+          throw new Error("Connected command reconciliation proof conflicts with durable proof");
+        }
+        return;
+      }
+      const rows = await scopedDb.update(sessionBackgroundCommands).set({
+        reconcileProofOutcome: input.proof.outcome,
+        reconcileProofExitCode: input.proof.exitCode,
+        reconcileProofReason: reason,
+        reconcileProofObservedAt: input.proof.observedAt,
+        lastReconcileOutcome: `proof_${input.proof.outcome}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(connectedClaimIdentityWhere(input.claim)).returning({ id: sessionBackgroundCommands.id });
+      if (rows.length !== 1) {
+        throw new Error("Connected command proof lost its exact claim during checkpoint");
+      }
+    }
+  );
+}
+async function deferConnectedMachineBackgroundCommandReconciliation(db, input) {
+  if (!Number.isSafeInteger(input.retryAfterMs) || input.retryAfterMs < 0) {
+    throw new Error("Connected command reconciliation retry delay is invalid");
+  }
+  const outcome = input.outcome.trim().slice(0, 64);
+  if (!outcome) throw new Error("Connected command reconciliation outcome must not be empty");
+  return await withRlsContext(
+    db,
+    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.update(sessionBackgroundCommands).set({
+        reconcileAfter: new Date(Date.now() + input.retryAfterMs),
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        lastReconcileOutcome: outcome,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(connectedClaimIdentityWhere(input.claim)).returning({ id: sessionBackgroundCommands.id });
+      return rows.length === 1;
+    }
+  );
+}
+async function settleClaimedConnectedMachineBackgroundCommand(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },
+    async (scopedDb) => {
+      const rows = await scopedDb.execute(sql`
+        update ${sessionBackgroundCommands} command set
+          state = command.reconcile_proof_outcome,
+          exit_code = case
+            when command.reconcile_proof_outcome = 'exited'
+              then command.reconcile_proof_exit_code
+            else null
+          end,
+          settlement_reason = command.reconcile_proof_reason,
+          settled_at = command.reconcile_proof_observed_at,
+          reconcile_claim_id = null,
+          reconcile_claimed_at = null,
+          last_reconcile_outcome = 'settled_' || command.reconcile_proof_outcome,
+          updated_at = clock_timestamp()
+        where command.id = ${input.claim.commandId}
+          and command.account_id = ${input.claim.accountId}
+          and command.workspace_id = ${input.claim.workspaceId}
+          and command.session_id = ${input.claim.sessionId}
+          and command.provider = 'connected_machine'
+          and command.control_workspace_id = ${input.claim.controlWorkspaceId}
+          and command.enrollment_id = ${input.claim.enrollmentId}
+          and command.connection_instance_id = ${input.claim.connectionInstanceId}
+          and command.op_id = ${input.claim.opId}
+          and command.reconcile_claim_id = ${input.claim.claimId}
+          and command.state in ('running', 'stopping')
+          and command.reconcile_proof_outcome in ('exited', 'lost')
+          and command.reconcile_proof_observed_at is not null
+        returning command.id
+      `);
+      return rows.length === 1;
+    }
+  );
+}
+async function requestSessionBackgroundCommandCancellation(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => await scopedDb.transaction(async (tx) => {
+      const [current] = await tx.select().from(sessionBackgroundCommands).where(
+        and(
+          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq(sessionBackgroundCommands.sessionId, input.sessionId),
+          eq(sessionBackgroundCommands.id, input.commandId)
+        )
+      ).for("update").limit(1);
+      if (!current) return { command: null, accepted: false };
+      if (current.state !== "running") {
+        return { command: mapCommand(current), accepted: false };
+      }
+      const [updated] = await tx.update(sessionBackgroundCommands).set({
+        state: "stopping",
+        cancelRequestedAt: /* @__PURE__ */ new Date(),
+        cancelRequestedBy: input.subjectId.slice(0, 1024),
+        reconcileAfter: /* @__PURE__ */ new Date(),
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(eq(sessionBackgroundCommands.id, current.id)).returning();
+      if (current.retainedProcessId) {
+        await tx.update(sandboxRetainedProcesses).set({ reconcileAfter: /* @__PURE__ */ new Date(), lastReconcileOutcome: "cancel_requested" }).where(
+          and(
+            eq(sandboxRetainedProcesses.id, current.retainedProcessId),
+            eq(sandboxRetainedProcesses.state, "active"),
+            sql`${sandboxRetainedProcesses.reconcileClaimId} is null`
+          )
+        );
+      }
+      return { command: mapCommand(updated), accepted: true };
+    })
+  );
+}
+async function requestSessionBackgroundCommandCancellationsInTransaction(db, input) {
+  const rootSessionIds = [...new Set(input.rootSessionIds)];
+  if (rootSessionIds.length === 0) return 0;
+  const rows = await db.execute(sql`
+    with recursive roots(id) as (
+      values ${sql.join(
+    rootSessionIds.map((sessionId) => sql`(${sessionId}::uuid)`),
+    sql`, `
+  )}
+    ), subtree(id, path, cycle) as (
+      select session.id, array[session.id]::uuid[], false
+      from roots root
+      join ${sessions} session
+        on session.workspace_id = ${input.workspaceId}
+       and session.id = root.id
+      union all
+      select child.id, parent.path || child.id, child.id = any(parent.path)
+      from subtree parent
+      join ${sessions} child
+        on child.workspace_id = ${input.workspaceId}
+       and child.parent_session_id = parent.id
+      where not parent.cycle
+    ), stopped as (
+      update ${sessionBackgroundCommands} command set
+        state = 'stopping',
+        cancel_requested_at = clock_timestamp(),
+        cancel_requested_by = left(${input.subjectId}, 1024),
+        reconcile_after = clock_timestamp(),
+        reconcile_claim_id = null,
+        reconcile_claimed_at = null,
+        updated_at = clock_timestamp()
+      where command.workspace_id = ${input.workspaceId}
+        and command.session_id in (select id from subtree where not cycle)
+        and command.state = 'running'
+      returning command.retained_process_id
+    ), nudged as (
+      update ${sandboxRetainedProcesses} process set
+        reconcile_after = clock_timestamp(),
+        reconcile_claim_id = null,
+        reconcile_claimed_at = null,
+        last_reconcile_outcome = 'cancel_requested'
+      where process.id in (
+        select stopped.retained_process_id
+        from stopped
+        where stopped.retained_process_id is not null
+      )
+        and process.state = 'active'
+      returning process.id
+    )
+    select count(*)::integer as "commandCount" from stopped
+  `);
+  return Number(rows[0]?.commandCount ?? 0);
+}
+async function requestWorkspaceBackgroundCommandCancellationsInTransaction(db, input) {
+  const rows = await db.execute(sql`
+    with stopped as (
+      update ${sessionBackgroundCommands} command set
+        state = 'stopping',
+        cancel_requested_at = clock_timestamp(),
+        cancel_requested_by = left(${input.subjectId}, 1024),
+        reconcile_after = clock_timestamp(),
+        reconcile_claim_id = null,
+        reconcile_claimed_at = null,
+        updated_at = clock_timestamp()
+      where command.workspace_id = ${input.workspaceId}
+        and command.state = 'running'
+      returning command.retained_process_id
+    ), nudged as (
+      update ${sandboxRetainedProcesses} process set
+        reconcile_after = clock_timestamp(),
+        reconcile_claim_id = null,
+        reconcile_claimed_at = null,
+        last_reconcile_outcome = 'cancel_requested'
+      where process.id in (
+        select stopped.retained_process_id
+        from stopped
+        where stopped.retained_process_id is not null
+      )
+        and process.state = 'active'
+      returning process.id
+    )
+    select count(*)::integer as "commandCount" from stopped
+  `);
+  return Number(rows[0]?.commandCount ?? 0);
+}
+async function settleSessionBackgroundCommandForRetainedProcess(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const [row] = await scopedDb.update(sessionBackgroundCommands).set({
+        state: input.outcome,
+        exitCode: input.outcome === "exited" ? input.exitCode : null,
+        settlementReason: input.reason.slice(0, 512),
+        settledAt: /* @__PURE__ */ new Date(),
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        lastReconcileOutcome: `settled_${input.outcome}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(
+        and(
+          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq(sessionBackgroundCommands.sessionId, input.sessionId),
+          eq(sessionBackgroundCommands.retainedProcessId, input.retainedProcessId),
+          inArray(sessionBackgroundCommands.state, ["running", "stopping"])
+        )
+      ).returning();
+      return row ? mapCommand(row) : null;
+    }
+  );
+}
+async function settleConnectedMachineSessionBackgroundCommand(db, input) {
+  return await withRlsContext(
+    db,
+    { accountId: input.accountId, workspaceId: input.workspaceId },
+    async (scopedDb) => {
+      const settledAt = /* @__PURE__ */ new Date();
+      const reason = input.reason.trim().slice(0, 512);
+      if (!reason) throw new Error("Connected command settlement reason must not be empty");
+      if (input.outcome === "exited" && input.exitCode === null) {
+        throw new Error("Connected command exit settlement requires an exit code");
+      }
+      if (input.outcome === "lost" && input.exitCode !== null) {
+        throw new Error("Connected command loss settlement cannot carry an exit code");
+      }
+      const [row] = await scopedDb.update(sessionBackgroundCommands).set({
+        state: input.outcome,
+        exitCode: input.outcome === "exited" ? input.exitCode : null,
+        settlementReason: reason,
+        settledAt,
+        reconcileClaimId: null,
+        reconcileClaimedAt: null,
+        reconcileProofOutcome: input.outcome,
+        reconcileProofExitCode: input.outcome === "exited" ? input.exitCode : null,
+        reconcileProofReason: reason,
+        reconcileProofObservedAt: settledAt,
+        lastReconcileOutcome: `settled_${input.outcome}`,
+        updatedAt: /* @__PURE__ */ new Date()
+      }).where(
+        and(
+          eq(sessionBackgroundCommands.workspaceId, input.workspaceId),
+          eq(sessionBackgroundCommands.sessionId, input.sessionId),
+          eq(sessionBackgroundCommands.id, input.commandId),
+          eq(sessionBackgroundCommands.provider, "connected_machine"),
+          eq(sessionBackgroundCommands.controlWorkspaceId, input.controlWorkspaceId),
+          eq(sessionBackgroundCommands.enrollmentId, input.enrollmentId),
+          eq(sessionBackgroundCommands.connectionInstanceId, input.connectionInstanceId),
+          eq(sessionBackgroundCommands.opId, input.opId),
+          inArray(sessionBackgroundCommands.state, ["running", "stopping"])
+        )
+      ).returning();
+      return row ? mapCommand(row) : null;
+    }
+  );
+}
+
+export {
+  backgroundCommandActivityForSessions,
+  listSessionBackgroundCommands,
+  insertManagedSessionBackgroundCommandInTransaction,
+  insertConnectedMachineSessionBackgroundCommandInTransaction,
+  claimConnectedMachineSessionBackgroundCommands,
+  recordConnectedMachineBackgroundCommandProof,
+  deferConnectedMachineBackgroundCommandReconciliation,
+  settleClaimedConnectedMachineBackgroundCommand,
+  requestSessionBackgroundCommandCancellation,
+  requestSessionBackgroundCommandCancellationsInTransaction,
+  requestWorkspaceBackgroundCommandCancellationsInTransaction,
+  settleSessionBackgroundCommandForRetainedProcess,
+  settleConnectedMachineSessionBackgroundCommand
+};
+//# sourceMappingURL=chunk-ZZ5LJEFX.js.map

package/dist/chunk-ZZ5LJEFX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/session-background-commands.ts"],"sourcesContent":["import type {\n  SessionBackgroundCommand,\n  SessionBackgroundCommandActivity,\n} from \"@opengeni/contracts\";\nimport { and, desc, eq, inArray, sql } from \"drizzle-orm\";\n\nimport type { Database } from \"./database\";\nimport { withRlsContext } from \"./database\";\nimport * as schema from \"./schema\";\n\nexport type ConnectedMachineBackgroundCommandProof = {\n  outcome: \"exited\" | \"lost\";\n  exitCode: number | null;\n  reason: string;\n  observedAt: Date;\n};\n\nexport type ConnectedMachineBackgroundCommandClaim = {\n  commandId: string;\n  accountId: string;\n  workspaceId: string;\n  sessionId: string;\n  claimId: string;\n  state: \"running\" | \"stopping\";\n  controlWorkspaceId: string;\n  enrollmentId: string;\n  connectionInstanceId: string;\n  opId: string;\n  reconcileAttempts: number;\n  proof: ConnectedMachineBackgroundCommandProof | null;\n};\n\ntype ConnectedMachineBackgroundCommandClaimRow = {\n  accountId: string;\n  workspaceId: string;\n  sessionId: string;\n  commandId: string;\n  claimId: string;\n  commandState: string;\n  controlWorkspaceId: string;\n  enrollmentId: string;\n  connectionInstanceId: string;\n  opId: string;\n  reconcileAttempts: number | string;\n  reconcileProofOutcome: string | null;\n  reconcileProofExitCode: number | string | null;\n  reconcileProofReason: string | null;\n  reconcileProofObservedAt: Date | string | null;\n};\n\nfunction commandPreview(value: string): string {\n  const normalized = value.replace(/\\s+/g, \" \").trim();\n  return Array.from(normalized).slice(0, 512).join(\"\");\n}\n\nfunction mapCommand(\n  row: typeof schema.sessionBackgroundCommands.$inferSelect,\n): SessionBackgroundCommand {\n  return {\n    id: row.id,\n    workspaceId: row.workspaceId,\n    sessionId: row.sessionId,\n    provider: row.provider,\n    state: row.state,\n    commandPreview: row.commandPreview,\n    cancelRequestedAt: row.cancelRequestedAt?.toISOString() ?? null,\n    exitCode: row.exitCode ?? null,\n    settlementReason: row.settlementReason ?? null,\n    startedAt: row.startedAt.toISOString(),\n    settledAt: row.settledAt?.toISOString() ?? null,\n    updatedAt: row.updatedAt.toISOString(),\n  };\n}\n\nexport async function backgroundCommandActivityForSessions(\n  db: Database,\n  input: { accountId: string; workspaceId: string; sessionIds: string[] },\n): Promise<Map<string, SessionBackgroundCommandActivity>> {\n  if (input.sessionIds.length === 0) return new Map();\n  return await withRlsContext(\n    db,\n    { accountId: input.accountId, workspaceId: input.workspaceId },\n    async (scopedDb) => {\n      const rows = await scopedDb\n        .select({\n          sessionId: schema.sessionBackgroundCommands.sessionId,\n          count: sql<number>`count(*)::int`,\n          stoppingCount: sql<number>`count(*) filter (where ${schema.sessionBackgroundCommands.state} = 'stopping')::int`,\n        })\n        .from(schema.sessionBackgroundCommands)\n        .where(\n          and(\n            eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),\n            inArray(schema.sessionBackgroundCommands.sessionId, input.sessionIds),\n            inArray(schema.sessionBackgroundCommands.state, [\"running\", \"stopping\"]),\n          ),\n        )\n        .groupBy(schema.sessionBackgroundCommands.sessionId);\n      return new Map(\n        rows.map((row) => [\n          row.sessionId,\n          {\n            state: Number(row.stoppingCount) > 0 ? (\"stopping\" as const) : (\"running\" as const),\n            count: Number(row.count),\n          },\n        ]),\n      );\n    },\n  );\n}\n\nexport async function listSessionBackgroundCommands(\n  db: Database,\n  input: { accountId: string; workspaceId: string; sessionId: string },\n): Promise<SessionBackgroundCommand[]> {\n  return await withRlsContext(\n    db,\n    { accountId: input.accountId, workspaceId: input.workspaceId },\n    async (scopedDb) => {\n      const rows = await scopedDb\n        .select()\n        .from(schema.sessionBackgroundCommands)\n        .where(\n          and(\n            eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),\n            eq(schema.sessionBackgroundCommands.sessionId, input.sessionId),\n          ),\n        )\n        .orderBy(\n          desc(schema.sessionBackgroundCommands.startedAt),\n          desc(schema.sessionBackgroundCommands.id),\n        )\n        .limit(1000);\n      return rows.map(mapCommand);\n    },\n  );\n}\n\n/** @internal Caller must already hold the canonical session/control fence. */\nexport async function insertManagedSessionBackgroundCommandInTransaction(\n  db: Database,\n  input: {\n    accountId: string;\n    workspaceId: string;\n    sessionId: string;\n    commandId: string;\n    retainedProcessId: string;\n    command: string;\n  },\n): Promise<SessionBackgroundCommand> {\n  const [process] = await db\n    .select({\n      accountId: schema.sandboxRetainedProcesses.accountId,\n      workspaceId: schema.sandboxRetainedProcesses.workspaceId,\n      sessionId: schema.sandboxRetainedProcesses.sessionId,\n      state: schema.sandboxRetainedProcesses.state,\n    })\n    .from(schema.sandboxRetainedProcesses)\n    .where(eq(schema.sandboxRetainedProcesses.id, input.retainedProcessId))\n    .for(\"update\")\n    .limit(1);\n  if (\n    !process ||\n    process.accountId !== input.accountId ||\n    process.workspaceId !== input.workspaceId ||\n    process.sessionId !== input.sessionId ||\n    process.state !== \"active\"\n  ) {\n    throw new Error(\"Managed background command requires its exact active retained process\");\n  }\n  const [row] = await db\n    .insert(schema.sessionBackgroundCommands)\n    .values({\n      id: input.commandId,\n      accountId: input.accountId,\n      workspaceId: input.workspaceId,\n      sessionId: input.sessionId,\n      provider: \"managed\",\n      state: \"running\",\n      retainedProcessId: input.retainedProcessId,\n      commandPreview: commandPreview(input.command),\n    })\n    .onConflictDoUpdate({\n      target: schema.sessionBackgroundCommands.retainedProcessId,\n      targetWhere: sql`${schema.sessionBackgroundCommands.retainedProcessId} is not null`,\n      set: { updatedAt: new Date() },\n    })\n    .returning();\n  if (!row) throw new Error(\"Managed background command adoption returned no row\");\n  if (\n    row.accountId !== input.accountId ||\n    row.workspaceId !== input.workspaceId ||\n    row.sessionId !== input.sessionId ||\n    row.provider !== \"managed\" ||\n    row.retainedProcessId !== input.retainedProcessId\n  ) {\n    throw new Error(\"Managed background command adoption conflicted with another identity\");\n  }\n  return mapCommand(row);\n}\n\n/** @internal Caller must already hold the canonical exact-attempt fence. */\nexport async function insertConnectedMachineSessionBackgroundCommandInTransaction(\n  db: Database,\n  input: {\n    accountId: string;\n    workspaceId: string;\n    sessionId: string;\n    commandId: string;\n    controlWorkspaceId: string;\n    enrollmentId: string;\n    connectionInstanceId: string;\n    opId: string;\n    command: string;\n  },\n): Promise<SessionBackgroundCommand> {\n  const [row] = await db\n    .insert(schema.sessionBackgroundCommands)\n    .values({\n      id: input.commandId,\n      accountId: input.accountId,\n      workspaceId: input.workspaceId,\n      sessionId: input.sessionId,\n      provider: \"connected_machine\",\n      state: \"running\",\n      controlWorkspaceId: input.controlWorkspaceId,\n      enrollmentId: input.enrollmentId,\n      connectionInstanceId: input.connectionInstanceId,\n      opId: input.opId,\n      commandPreview: commandPreview(input.command),\n    })\n    .onConflictDoUpdate({\n      target: [\n        schema.sessionBackgroundCommands.controlWorkspaceId,\n        schema.sessionBackgroundCommands.enrollmentId,\n        schema.sessionBackgroundCommands.connectionInstanceId,\n        schema.sessionBackgroundCommands.opId,\n      ],\n      targetWhere: sql`${schema.sessionBackgroundCommands.provider} = 'connected_machine'`,\n      set: { updatedAt: new Date() },\n    })\n    .returning();\n  if (!row) throw new Error(\"Connected Machine background command adoption returned no row\");\n  if (\n    row.accountId !== input.accountId ||\n    row.workspaceId !== input.workspaceId ||\n    row.sessionId !== input.sessionId ||\n    row.provider !== \"connected_machine\" ||\n    row.controlWorkspaceId !== input.controlWorkspaceId ||\n    row.enrollmentId !== input.enrollmentId ||\n    row.connectionInstanceId !== input.connectionInstanceId ||\n    row.opId !== input.opId\n  ) {\n    throw new Error(\n      \"Connected Machine background command adoption conflicted with another identity\",\n    );\n  }\n  return mapCommand(row);\n}\n\n/** Claim exact Connected Machine locators globally for provider reconciliation.\n * The SECURITY DEFINER SQL function owns the bounded SKIP LOCKED inventory;\n * claim expiry is coordination recovery only and never implies command loss. */\nexport async function claimConnectedMachineSessionBackgroundCommands(\n  db: Database,\n  input: { claimId: string; limit: number; claimTtlMs: number },\n): Promise<ConnectedMachineBackgroundCommandClaim[]> {\n  if (!Number.isSafeInteger(input.limit) || input.limit < 1 || input.limit > 100) {\n    throw new Error(\"Connected command reconciliation limit must be between 1 and 100\");\n  }\n  if (\n    !Number.isSafeInteger(input.claimTtlMs) ||\n    input.claimTtlMs < 0 ||\n    input.claimTtlMs > 3_600_000\n  ) {\n    throw new Error(\"Connected command reconciliation claim TTL is invalid\");\n  }\n  const rows = await db.execute<ConnectedMachineBackgroundCommandClaimRow>(sql`\n    select account_id as \"accountId\",\n      workspace_id as \"workspaceId\",\n      session_id as \"sessionId\",\n      command_id as \"commandId\",\n      claim_id as \"claimId\",\n      command_state as \"commandState\",\n      control_workspace_id as \"controlWorkspaceId\",\n      enrollment_id as \"enrollmentId\",\n      connection_instance_id as \"connectionInstanceId\",\n      op_id as \"opId\",\n      reconcile_attempts as \"reconcileAttempts\",\n      reconcile_proof_outcome as \"reconcileProofOutcome\",\n      reconcile_proof_exit_code as \"reconcileProofExitCode\",\n      reconcile_proof_reason as \"reconcileProofReason\",\n      reconcile_proof_observed_at as \"reconcileProofObservedAt\"\n    from opengeni_private.claim_connected_machine_background_commands(\n      ${input.claimId}::uuid, ${input.limit}::integer, ${input.claimTtlMs}::bigint\n    )\n  `);\n  return rows.map((row: ConnectedMachineBackgroundCommandClaimRow) => {\n    if (row.commandState !== \"running\" && row.commandState !== \"stopping\") {\n      throw new Error(`Connected command claim returned invalid state ${row.commandState}`);\n    }\n    const proof =\n      row.reconcileProofOutcome === null\n        ? null\n        : row.reconcileProofOutcome === \"exited\" || row.reconcileProofOutcome === \"lost\"\n          ? {\n              outcome: row.reconcileProofOutcome,\n              exitCode:\n                row.reconcileProofExitCode === null ? null : Number(row.reconcileProofExitCode),\n              reason: row.reconcileProofReason!,\n              observedAt:\n                row.reconcileProofObservedAt instanceof Date\n                  ? row.reconcileProofObservedAt\n                  : new Date(row.reconcileProofObservedAt!),\n            }\n          : (() => {\n              throw new Error(\n                `Connected command claim returned invalid proof ${row.reconcileProofOutcome}`,\n              );\n            })();\n    return {\n      commandId: row.commandId,\n      accountId: row.accountId,\n      workspaceId: row.workspaceId,\n      sessionId: row.sessionId,\n      claimId: row.claimId,\n      state: row.commandState,\n      controlWorkspaceId: row.controlWorkspaceId,\n      enrollmentId: row.enrollmentId,\n      connectionInstanceId: row.connectionInstanceId,\n      opId: row.opId,\n      reconcileAttempts: Number(row.reconcileAttempts),\n      proof,\n    };\n  });\n}\n\nfunction connectedClaimIdentityWhere(claim: ConnectedMachineBackgroundCommandClaim) {\n  return and(\n    eq(schema.sessionBackgroundCommands.id, claim.commandId),\n    eq(schema.sessionBackgroundCommands.accountId, claim.accountId),\n    eq(schema.sessionBackgroundCommands.workspaceId, claim.workspaceId),\n    eq(schema.sessionBackgroundCommands.sessionId, claim.sessionId),\n    eq(schema.sessionBackgroundCommands.provider, \"connected_machine\"),\n    eq(schema.sessionBackgroundCommands.controlWorkspaceId, claim.controlWorkspaceId),\n    eq(schema.sessionBackgroundCommands.enrollmentId, claim.enrollmentId),\n    eq(schema.sessionBackgroundCommands.connectionInstanceId, claim.connectionInstanceId),\n    eq(schema.sessionBackgroundCommands.opId, claim.opId),\n    eq(schema.sessionBackgroundCommands.reconcileClaimId, claim.claimId),\n    inArray(schema.sessionBackgroundCommands.state, [\"running\", \"stopping\"]),\n  );\n}\n\n/** Checkpoint one exact terminal provider observation before lifecycle settlement.\n * A retry may reuse an identical proof; a divergent proof is a hard identity fault. */\nexport async function recordConnectedMachineBackgroundCommandProof(\n  db: Database,\n  input: {\n    claim: ConnectedMachineBackgroundCommandClaim;\n    proof: ConnectedMachineBackgroundCommandProof;\n  },\n): Promise<void> {\n  const reason = input.proof.reason.trim().slice(0, 512);\n  if (!reason) throw new Error(\"Connected command proof reason must not be empty\");\n  if (input.proof.outcome === \"exited\" && input.proof.exitCode === null) {\n    throw new Error(\"Connected command exit proof requires an exit code\");\n  }\n  if (input.proof.outcome === \"lost\" && input.proof.exitCode !== null) {\n    throw new Error(\"Connected command loss proof cannot carry an exit code\");\n  }\n  await withRlsContext(\n    db,\n    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },\n    async (scopedDb) => {\n      const [current] = await scopedDb\n        .select()\n        .from(schema.sessionBackgroundCommands)\n        .where(connectedClaimIdentityWhere(input.claim))\n        .for(\"update\")\n        .limit(1);\n      if (!current) throw new Error(\"Connected command proof was fenced by newer lifecycle state\");\n      if (current.reconcileProofOutcome !== null) {\n        const observedAt = current.reconcileProofObservedAt?.getTime() ?? null;\n        if (\n          current.reconcileProofOutcome !== input.proof.outcome ||\n          current.reconcileProofExitCode !== input.proof.exitCode ||\n          current.reconcileProofReason !== reason ||\n          observedAt !== input.proof.observedAt.getTime()\n        ) {\n          throw new Error(\"Connected command reconciliation proof conflicts with durable proof\");\n        }\n        return;\n      }\n      const rows = await scopedDb\n        .update(schema.sessionBackgroundCommands)\n        .set({\n          reconcileProofOutcome: input.proof.outcome,\n          reconcileProofExitCode: input.proof.exitCode,\n          reconcileProofReason: reason,\n          reconcileProofObservedAt: input.proof.observedAt,\n          lastReconcileOutcome: `proof_${input.proof.outcome}`,\n          updatedAt: new Date(),\n        })\n        .where(connectedClaimIdentityWhere(input.claim))\n        .returning({ id: schema.sessionBackgroundCommands.id });\n      if (rows.length !== 1) {\n        throw new Error(\"Connected command proof lost its exact claim during checkpoint\");\n      }\n    },\n  );\n}\n\nexport async function deferConnectedMachineBackgroundCommandReconciliation(\n  db: Database,\n  input: {\n    claim: ConnectedMachineBackgroundCommandClaim;\n    outcome: string;\n    retryAfterMs: number;\n  },\n): Promise<boolean> {\n  if (!Number.isSafeInteger(input.retryAfterMs) || input.retryAfterMs < 0) {\n    throw new Error(\"Connected command reconciliation retry delay is invalid\");\n  }\n  const outcome = input.outcome.trim().slice(0, 64);\n  if (!outcome) throw new Error(\"Connected command reconciliation outcome must not be empty\");\n  return await withRlsContext(\n    db,\n    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },\n    async (scopedDb) => {\n      const rows = await scopedDb\n        .update(schema.sessionBackgroundCommands)\n        .set({\n          reconcileAfter: new Date(Date.now() + input.retryAfterMs),\n          reconcileClaimId: null,\n          reconcileClaimedAt: null,\n          lastReconcileOutcome: outcome,\n          updatedAt: new Date(),\n        })\n        .where(connectedClaimIdentityWhere(input.claim))\n        .returning({ id: schema.sessionBackgroundCommands.id });\n      return rows.length === 1;\n    },\n  );\n}\n\n/** Settle only from the proof already checkpointed under this exact claim. */\nexport async function settleClaimedConnectedMachineBackgroundCommand(\n  db: Database,\n  input: { claim: ConnectedMachineBackgroundCommandClaim },\n): Promise<boolean> {\n  return await withRlsContext(\n    db,\n    { accountId: input.claim.accountId, workspaceId: input.claim.workspaceId },\n    async (scopedDb) => {\n      const rows = await scopedDb.execute<{ id: string }>(sql`\n        update ${schema.sessionBackgroundCommands} command set\n          state = command.reconcile_proof_outcome,\n          exit_code = case\n            when command.reconcile_proof_outcome = 'exited'\n              then command.reconcile_proof_exit_code\n            else null\n          end,\n          settlement_reason = command.reconcile_proof_reason,\n          settled_at = command.reconcile_proof_observed_at,\n          reconcile_claim_id = null,\n          reconcile_claimed_at = null,\n          last_reconcile_outcome = 'settled_' || command.reconcile_proof_outcome,\n          updated_at = clock_timestamp()\n        where command.id = ${input.claim.commandId}\n          and command.account_id = ${input.claim.accountId}\n          and command.workspace_id = ${input.claim.workspaceId}\n          and command.session_id = ${input.claim.sessionId}\n          and command.provider = 'connected_machine'\n          and command.control_workspace_id = ${input.claim.controlWorkspaceId}\n          and command.enrollment_id = ${input.claim.enrollmentId}\n          and command.connection_instance_id = ${input.claim.connectionInstanceId}\n          and command.op_id = ${input.claim.opId}\n          and command.reconcile_claim_id = ${input.claim.claimId}\n          and command.state in ('running', 'stopping')\n          and command.reconcile_proof_outcome in ('exited', 'lost')\n          and command.reconcile_proof_observed_at is not null\n        returning command.id\n      `);\n      return rows.length === 1;\n    },\n  );\n}\n\nexport async function requestSessionBackgroundCommandCancellation(\n  db: Database,\n  input: {\n    accountId: string;\n    workspaceId: string;\n    sessionId: string;\n    commandId: string;\n    subjectId: string;\n  },\n): Promise<{ command: SessionBackgroundCommand | null; accepted: boolean }> {\n  return await withRlsContext(\n    db,\n    { accountId: input.accountId, workspaceId: input.workspaceId },\n    async (scopedDb) =>\n      await scopedDb.transaction(async (tx) => {\n        const [current] = await tx\n          .select()\n          .from(schema.sessionBackgroundCommands)\n          .where(\n            and(\n              eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),\n              eq(schema.sessionBackgroundCommands.sessionId, input.sessionId),\n              eq(schema.sessionBackgroundCommands.id, input.commandId),\n            ),\n          )\n          .for(\"update\")\n          .limit(1);\n        if (!current) return { command: null, accepted: false };\n        if (current.state !== \"running\") {\n          return { command: mapCommand(current), accepted: false };\n        }\n        const [updated] = await tx\n          .update(schema.sessionBackgroundCommands)\n          .set({\n            state: \"stopping\",\n            cancelRequestedAt: new Date(),\n            cancelRequestedBy: input.subjectId.slice(0, 1024),\n            reconcileAfter: new Date(),\n            reconcileClaimId: null,\n            reconcileClaimedAt: null,\n            updatedAt: new Date(),\n          })\n          .where(eq(schema.sessionBackgroundCommands.id, current.id))\n          .returning();\n        if (current.retainedProcessId) {\n          await tx\n            .update(schema.sandboxRetainedProcesses)\n            .set({ reconcileAfter: new Date(), lastReconcileOutcome: \"cancel_requested\" })\n            .where(\n              and(\n                eq(schema.sandboxRetainedProcesses.id, current.retainedProcessId),\n                eq(schema.sandboxRetainedProcesses.state, \"active\"),\n                sql`${schema.sandboxRetainedProcesses.reconcileClaimId} is null`,\n              ),\n            );\n        }\n        return { command: mapCommand(updated!), accepted: true };\n      }),\n  );\n}\n\n/**\n * Transfer every active command in one or more session subtrees to the\n * provider-neutral stopping state inside the caller's existing control\n * transaction. The workspace-control mutation already excludes concurrent\n * session-tree changes, so the recursive walk and state transition are one\n * atomic Pause/Cancel effect. Steer deliberately never calls this seam.\n */\nexport async function requestSessionBackgroundCommandCancellationsInTransaction(\n  db: Database,\n  input: {\n    workspaceId: string;\n    rootSessionIds: string[];\n    subjectId: string;\n  },\n): Promise<number> {\n  const rootSessionIds = [...new Set(input.rootSessionIds)];\n  if (rootSessionIds.length === 0) return 0;\n  const rows = await db.execute<{ commandCount: number | string }>(sql`\n    with recursive roots(id) as (\n      values ${sql.join(\n        rootSessionIds.map((sessionId) => sql`(${sessionId}::uuid)`),\n        sql`, `,\n      )}\n    ), subtree(id, path, cycle) as (\n      select session.id, array[session.id]::uuid[], false\n      from roots root\n      join ${schema.sessions} session\n        on session.workspace_id = ${input.workspaceId}\n       and session.id = root.id\n      union all\n      select child.id, parent.path || child.id, child.id = any(parent.path)\n      from subtree parent\n      join ${schema.sessions} child\n        on child.workspace_id = ${input.workspaceId}\n       and child.parent_session_id = parent.id\n      where not parent.cycle\n    ), stopped as (\n      update ${schema.sessionBackgroundCommands} command set\n        state = 'stopping',\n        cancel_requested_at = clock_timestamp(),\n        cancel_requested_by = left(${input.subjectId}, 1024),\n        reconcile_after = clock_timestamp(),\n        reconcile_claim_id = null,\n        reconcile_claimed_at = null,\n        updated_at = clock_timestamp()\n      where command.workspace_id = ${input.workspaceId}\n        and command.session_id in (select id from subtree where not cycle)\n        and command.state = 'running'\n      returning command.retained_process_id\n    ), nudged as (\n      update ${schema.sandboxRetainedProcesses} process set\n        reconcile_after = clock_timestamp(),\n        reconcile_claim_id = null,\n        reconcile_claimed_at = null,\n        last_reconcile_outcome = 'cancel_requested'\n      where process.id in (\n        select stopped.retained_process_id\n        from stopped\n        where stopped.retained_process_id is not null\n      )\n        and process.state = 'active'\n      returning process.id\n    )\n    select count(*)::integer as \"commandCount\" from stopped\n  `);\n  return Number(rows[0]?.commandCount ?? 0);\n}\n\n/** Workspace Pause owns every active command in that workspace. */\nexport async function requestWorkspaceBackgroundCommandCancellationsInTransaction(\n  db: Database,\n  input: { workspaceId: string; subjectId: string },\n): Promise<number> {\n  const rows = await db.execute<{ commandCount: number | string }>(sql`\n    with stopped as (\n      update ${schema.sessionBackgroundCommands} command set\n        state = 'stopping',\n        cancel_requested_at = clock_timestamp(),\n        cancel_requested_by = left(${input.subjectId}, 1024),\n        reconcile_after = clock_timestamp(),\n        reconcile_claim_id = null,\n        reconcile_claimed_at = null,\n        updated_at = clock_timestamp()\n      where command.workspace_id = ${input.workspaceId}\n        and command.state = 'running'\n      returning command.retained_process_id\n    ), nudged as (\n      update ${schema.sandboxRetainedProcesses} process set\n        reconcile_after = clock_timestamp(),\n        reconcile_claim_id = null,\n        reconcile_claimed_at = null,\n        last_reconcile_outcome = 'cancel_requested'\n      where process.id in (\n        select stopped.retained_process_id\n        from stopped\n        where stopped.retained_process_id is not null\n      )\n        and process.state = 'active'\n      returning process.id\n    )\n    select count(*)::integer as \"commandCount\" from stopped\n  `);\n  return Number(rows[0]?.commandCount ?? 0);\n}\n\nexport async function settleSessionBackgroundCommandForRetainedProcess(\n  db: Database,\n  input: {\n    accountId: string;\n    workspaceId: string;\n    sessionId: string;\n    retainedProcessId: string;\n    outcome: \"exited\" | \"lost\";\n    exitCode: number | null;\n    reason: string;\n  },\n): Promise<SessionBackgroundCommand | null> {\n  return await withRlsContext(\n    db,\n    { accountId: input.accountId, workspaceId: input.workspaceId },\n    async (scopedDb) => {\n      const [row] = await scopedDb\n        .update(schema.sessionBackgroundCommands)\n        .set({\n          state: input.outcome,\n          exitCode: input.outcome === \"exited\" ? input.exitCode : null,\n          settlementReason: input.reason.slice(0, 512),\n          settledAt: new Date(),\n          reconcileClaimId: null,\n          reconcileClaimedAt: null,\n          lastReconcileOutcome: `settled_${input.outcome}`,\n          updatedAt: new Date(),\n        })\n        .where(\n          and(\n            eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),\n            eq(schema.sessionBackgroundCommands.sessionId, input.sessionId),\n            eq(schema.sessionBackgroundCommands.retainedProcessId, input.retainedProcessId),\n            inArray(schema.sessionBackgroundCommands.state, [\"running\", \"stopping\"]),\n          ),\n        )\n        .returning();\n      return row ? mapCommand(row) : null;\n    },\n  );\n}\n\nexport async function settleConnectedMachineSessionBackgroundCommand(\n  db: Database,\n  input: {\n    accountId: string;\n    workspaceId: string;\n    sessionId: string;\n    commandId: string;\n    controlWorkspaceId: string;\n    enrollmentId: string;\n    connectionInstanceId: string;\n    opId: string;\n    outcome: \"exited\" | \"lost\";\n    exitCode: number | null;\n    reason: string;\n  },\n): Promise<SessionBackgroundCommand | null> {\n  return await withRlsContext(\n    db,\n    { accountId: input.accountId, workspaceId: input.workspaceId },\n    async (scopedDb) => {\n      const settledAt = new Date();\n      const reason = input.reason.trim().slice(0, 512);\n      if (!reason) throw new Error(\"Connected command settlement reason must not be empty\");\n      if (input.outcome === \"exited\" && input.exitCode === null) {\n        throw new Error(\"Connected command exit settlement requires an exit code\");\n      }\n      if (input.outcome === \"lost\" && input.exitCode !== null) {\n        throw new Error(\"Connected command loss settlement cannot carry an exit code\");\n      }\n      const [row] = await scopedDb\n        .update(schema.sessionBackgroundCommands)\n        .set({\n          state: input.outcome,\n          exitCode: input.outcome === \"exited\" ? input.exitCode : null,\n          settlementReason: reason,\n          settledAt,\n          reconcileClaimId: null,\n          reconcileClaimedAt: null,\n          reconcileProofOutcome: input.outcome,\n          reconcileProofExitCode: input.outcome === \"exited\" ? input.exitCode : null,\n          reconcileProofReason: reason,\n          reconcileProofObservedAt: settledAt,\n          lastReconcileOutcome: `settled_${input.outcome}`,\n          updatedAt: new Date(),\n        })\n        .where(\n          and(\n            eq(schema.sessionBackgroundCommands.workspaceId, input.workspaceId),\n            eq(schema.sessionBackgroundCommands.sessionId, input.sessionId),\n            eq(schema.sessionBackgroundCommands.id, input.commandId),\n            eq(schema.sessionBackgroundCommands.provider, \"connected_machine\"),\n            eq(schema.sessionBackgroundCommands.controlWorkspaceId, input.controlWorkspaceId),\n            eq(schema.sessionBackgroundCommands.enrollmentId, input.enrollmentId),\n            eq(schema.sessionBackgroundCommands.connectionInstanceId, input.connectionInstanceId),\n            eq(schema.sessionBackgroundCommands.opId, input.opId),\n            inArray(schema.sessionBackgroundCommands.state, [\"running\", \"stopping\"]),\n          ),\n        )\n        .returning();\n      return row ? mapCommand(row) : null;\n    },\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/codemode-operations.d.ts

@@ -16,10 +16,6 @@ export declare class CodemodeToolApprovalRequiredError extends Error {
     readonly code = "codemode_tool_approval_required";
     constructor();
 }
-export declare class CodemodeCallBudgetExceededError extends Error {
-    readonly code = "codemode_call_budget_exhausted";
-    constructor();
-}
 export declare class CodemodePayloadTooLargeError extends Error {
     readonly code = "codemode_payload_too_large";
     constructor(kind: "arguments" | "result");
@@ -32,12 +28,11 @@ export type SubmitCodemodeOperationInput = {
     attemptId: string;
     executionGeneration: number;
     call: AttemptToolCallValue;
-    callLimit: number;
 };
 /**
  * Bind one caller-provided operation id to one exact catalog call. Duplicate
  * submission of identical bytes is free and returns the same row; repurposing
- * the id fails. Admission, budget reservation and insert share one turn lock.
+ * the id fails. Admission and insert share one turn lock.
  */
 export declare function submitCodemodeOperation(db: Database, input: SubmitCodemodeOperationInput): Promise<{
     operation: CodemodeOperationValue;