@opengeni/db 5.0.1 → 6.0.0

package/src/session-retry.ts

@@ -0,0 +1,319 @@
+import {
+  metadataWithTurnExecutionPolicyV1,
+  type SessionRetryRequest,
+  type SessionRetryResponse,
+  SessionRetryResponse as SessionRetryResponseSchema,
+  type TurnExecutionPolicyV1,
+} from "@opengeni/contracts";
+import { and, desc, eq, sql } from "drizzle-orm";
+import { rawRows, type Database, type SessionActivityDatabase } from "./database";
+import * as schema from "./schema";
+import { clearCodexCapacityRecovery } from "./codex-capacity-recovery";
+import { fromPostgresLosslessJson, withLosslessContentWriteVersion } from "./lossless-json";
+import { sessionAttemptPendingWritersSql } from "./session-attempt-writers";
+import {
+  canonicalSessionCommandHash,
+  evaluateSessionControl,
+  lockSessionEventWriteRows,
+  registerSessionWorkflowWakeInTransaction,
+  reserveSessionCommandReceipt,
+  updateSessionCommandReceiptResult,
+  SessionCommandIdempotencyError,
+} from "./session-control";
+
+export class SessionRetryConflictError extends Error {
+  constructor(
+    readonly code:
+      | "RETRY_STALE_FAILURE"
+      | "RETRY_EXECUTION_UNRESOLVED"
+      | "RETRY_PAUSED"
+      | "RETRY_SANDBOX_RECOVERY_REQUIRED"
+      | "RETRY_UNSUPPORTED_FAILURE",
+    message: string,
+  ) {
+    super(message);
+    this.name = "SessionRetryConflictError";
+  }
+}
+
+/** Authorized receipt reads precede mutable model/billing admission checks. */
+export async function getSessionRetryReceiptInTransaction(
+  db: Database,
+  input: {
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+    request: SessionRetryRequest;
+  },
+): Promise<SessionRetryResponse | null> {
+  const [receipt] = await db
+    .select()
+    .from(schema.sessionCommandReceipts)
+    .where(
+      and(
+        eq(schema.sessionCommandReceipts.workspaceId, input.workspaceId),
+        eq(schema.sessionCommandReceipts.targetSessionId, input.sessionId),
+        eq(schema.sessionCommandReceipts.actorType, "human"),
+        eq(schema.sessionCommandReceipts.actorSubjectId, input.subjectId),
+        eq(schema.sessionCommandReceipts.action, "session.retry"),
+        eq(schema.sessionCommandReceipts.operationKey, input.request.clientEventId),
+      ),
+    )
+    .limit(1);
+  if (!receipt) return null;
+  if (receipt.canonicalRequestHash !== canonicalSessionCommandHash(input.request))
+    throw new SessionCommandIdempotencyError();
+  return { ...SessionRetryResponseSchema.parse(receipt.result), outcome: "replayed" };
+}
+
+type EffectiveSandboxRecoveryBlocked = (
+  db: Database,
+  session: typeof schema.sessions.$inferSelect,
+) => Promise<boolean>;
+
+/** The root composition binds the canonical effective-route guard. Keep this
+ * leaf independent of the root barrel; there is no permissive default. */
+export function createRetryFailedSessionInTransaction(
+  sessionEffectiveSandboxRecoveryBlocked: EffectiveSandboxRecoveryBlocked,
+) {
+  return (
+    db: SessionActivityDatabase,
+    input: Parameters<typeof retryFailedSessionInTransaction>[1],
+  ) => retryFailedSessionInTransaction(db, input, sessionEffectiveSandboxRecoveryBlocked);
+}
+
+/** Caller owns the tenant/activity transaction and authorization. No provider I/O. */
+async function retryFailedSessionInTransaction(
+  db: SessionActivityDatabase,
+  input: {
+    accountId: string;
+    workspaceId: string;
+    sessionId: string;
+    subjectId: string;
+    request: SessionRetryRequest;
+    executionPolicy: TurnExecutionPolicyV1;
+  },
+  sessionEffectiveSandboxRecoveryBlocked: EffectiveSandboxRecoveryBlocked,
+): Promise<SessionRetryResponse & { eventIds: string[] }> {
+  const { accountId, workspaceId, sessionId, request } = input;
+  const locks = await lockSessionEventWriteRows(db, {
+    workspaceId,
+    controlLock: "share",
+    sessionIds: [sessionId],
+  });
+  const session = locks.sessions[0];
+  if (!session || session.accountId !== accountId)
+    throw new SessionRetryConflictError("RETRY_STALE_FAILURE", "Session is unavailable");
+  const reserved = await reserveSessionCommandReceipt(db, {
+    accountId,
+    workspaceId,
+    targetSessionId: sessionId,
+    targetTurnId: null,
+    actor: { type: "human", subjectId: input.subjectId },
+    action: "session.retry",
+    operationKey: request.clientEventId,
+    canonicalRequestHash: canonicalSessionCommandHash(request),
+  });
+  if (reserved.replay)
+    return {
+      ...SessionRetryResponseSchema.parse(reserved.receipt.result),
+      outcome: "replayed",
+      eventIds: [],
+    };
+  const control = await evaluateSessionControl(db, workspaceId, sessionId, {
+    workspaceControl: locks.control ?? undefined,
+  });
+  if (control.state !== "active")
+    throw new SessionRetryConflictError(
+      "RETRY_PAUSED",
+      "Resume the deliberately paused workstream before retrying",
+    );
+  if (session.status !== "failed" || session.activeTurnId !== null)
+    throw new SessionRetryConflictError(
+      "RETRY_STALE_FAILURE",
+      "The failed session boundary changed",
+    );
+  const [failure] = await db
+    .select()
+    .from(schema.sessionEvents)
+    .where(
+      and(
+        eq(schema.sessionEvents.workspaceId, workspaceId),
+        eq(schema.sessionEvents.sessionId, sessionId),
+        sql`(${schema.sessionEvents.turnAssociation} is null or ${schema.sessionEvents.turnAssociation} = 'current')`,
+        sql`(${schema.sessionEvents.type} = 'turn.failed' or (${schema.sessionEvents.type} = 'session.status.changed' and ${schema.sessionEvents.payload}->>'status' = 'failed' and ${schema.sessionEvents.turnId} is null))`,
+      ),
+    )
+    .orderBy(desc(schema.sessionEvents.sequence))
+    .limit(1);
+  if (!failure || failure.id !== request.failureEventId)
+    throw new SessionRetryConflictError(
+      "RETRY_STALE_FAILURE",
+      "The failure event is no longer current",
+    );
+  const failurePayload = fromPostgresLosslessJson(failure.payload, failure.payloadCodecVersion);
+  if (
+    failurePayload !== null &&
+    typeof failurePayload === "object" &&
+    !Array.isArray(failurePayload) &&
+    (failurePayload as Record<string, unknown>).code === "provider_safety_refusal"
+  )
+    throw new SessionRetryConflictError(
+      "RETRY_UNSUPPORTED_FAILURE",
+      "A provider safety refusal cannot be retried as the same logical turn",
+    );
+  if (!failure.turnId)
+    throw new SessionRetryConflictError(
+      "RETRY_UNSUPPORTED_FAILURE",
+      "This failure has no retained logical turn to retry",
+    );
+  const [turn] = await db
+    .select()
+    .from(schema.sessionTurns)
+    .where(
+      and(
+        eq(schema.sessionTurns.workspaceId, workspaceId),
+        eq(schema.sessionTurns.sessionId, sessionId),
+        eq(schema.sessionTurns.id, failure.turnId),
+      ),
+    )
+    .for("update");
+  if (!turn || turn.status !== "failed" || turn.activeAttemptId !== null)
+    throw new SessionRetryConflictError("RETRY_STALE_FAILURE", "The failed turn changed");
+  if (failure.turnGeneration !== null && failure.turnGeneration !== turn.executionGeneration)
+    throw new SessionRetryConflictError(
+      "RETRY_STALE_FAILURE",
+      "The failed execution generation changed",
+    );
+  if (turn.scheduledTaskRunId !== null)
+    throw new SessionRetryConflictError(
+      "RETRY_UNSUPPORTED_FAILURE",
+      "A settled scheduled occurrence cannot be reopened as a human retry",
+    );
+  const [unresolved] = await rawRows<{ pending: boolean }>(
+    db,
+    sql`select (
+    exists (select 1 from session_turn_attempts attempt where attempt.workspace_id = ${workspaceId} and attempt.session_id = ${sessionId}
+      and (attempt.state <> 'closed' or ${sessionAttemptPendingWritersSql(sql`attempt`)}
+        or (attempt.quiesced_at is null and exists (select 1 from session_attempt_interruptions interruption where interruption.attempt_id = attempt.id))))
+    or exists (select 1 from session_pending_tool_calls pending where pending.workspace_id = ${workspaceId} and pending.session_id = ${sessionId})
+    or exists (select 1 from session_events tool_event where tool_event.workspace_id = ${workspaceId} and tool_event.session_id = ${sessionId} and tool_event.turn_id = ${turn.id}
+      and tool_event.type = 'agent.toolCall.output' and tool_event.payload->'recovery'->>'outcome' = 'unknown')
+    or exists (select 1 from session_turns live where live.workspace_id = ${workspaceId} and live.session_id = ${sessionId} and live.status in ('running', 'recovering', 'requires_action', 'waiting_capacity'))
+  ) as pending`,
+  );
+  if (unresolved?.pending)
+    throw new SessionRetryConflictError(
+      "RETRY_EXECUTION_UNRESOLVED",
+      "Execution or tool settlement is unresolved; retry cannot replay it",
+    );
+  const now = new Date();
+  if (await sessionEffectiveSandboxRecoveryBlocked(db, session))
+    throw new SessionRetryConflictError(
+      "RETRY_SANDBOX_RECOVERY_REQUIRED",
+      "The effective sandbox route requires recovery; review its checkpoint before retrying",
+    );
+  // A never-claimed prompt must traverse normal first claim exactly once so
+  // its original user history item is inserted. Started turns retain history.
+  const preclaim = turn.executionGeneration === 0;
+  const policy = input.executionPolicy;
+  const capacityRecoveryRetry =
+    failurePayload !== null &&
+    typeof failurePayload === "object" &&
+    !Array.isArray(failurePayload) &&
+    (failurePayload as Record<string, unknown>).code === "codex_capacity_recovery_exhausted";
+  // Only this explicitly authorized, exact failure-event Retry may replenish
+  // the breaker. Preserve accepted credential policy/refusal ledgers and all
+  // unrelated recovery budgets. Receipt replay returned above cannot reset it.
+  const retryMetadata = capacityRecoveryRetry
+    ? clearCodexCapacityRecovery(turn.metadata ?? {})
+    : turn.metadata;
+  if (capacityRecoveryRetry) {
+    await db
+      .update(schema.sessionGoals)
+      .set({ continuationSuppressedTurnId: null, updatedAt: now })
+      .where(
+        and(
+          eq(schema.sessionGoals.workspaceId, workspaceId),
+          eq(schema.sessionGoals.sessionId, sessionId),
+          eq(schema.sessionGoals.continuationSuppressedTurnId, turn.id),
+        ),
+      );
+  }
+  await db
+    .update(schema.sessionTurns)
+    .set({
+      status: preclaim ? "queued" : "recovering",
+      finishedAt: null,
+      updatedAt: now,
+      version: turn.version + 1,
+      model: policy.productModelId,
+      reasoningEffort: policy.reasoningEffort,
+      latencyMode: policy.latencyMode,
+      metadata: metadataWithTurnExecutionPolicyV1(retryMetadata, policy),
+    })
+    .where(eq(schema.sessionTurns.id, turn.id));
+  const events = await db
+    .insert(schema.sessionEvents)
+    .values(
+      withLosslessContentWriteVersion(
+        [
+          {
+            accountId,
+            workspaceId,
+            sessionId,
+            sequence: session.lastSequence + 1,
+            type: "turn.recovery.requested",
+            turnId: turn.id,
+            turnGeneration: turn.executionGeneration,
+            turnAssociation: "current",
+            payload: {
+              reason: "human_retry",
+              failureEventId: failure.id,
+              operationId: request.clientEventId,
+              model: policy.productModelId,
+              reasoningEffort: policy.reasoningEffort,
+              latencyMode: policy.latencyMode,
+            },
+            occurredAt: now,
+          },
+          {
+            accountId,
+            workspaceId,
+            sessionId,
+            sequence: session.lastSequence + 2,
+            type: "session.status.changed",
+            turnId: turn.id,
+            turnGeneration: turn.executionGeneration,
+            turnAssociation: "current",
+            payload: { status: preclaim ? "queued" : "recovering" },
+            occurredAt: now,
+          },
+        ],
+        "payload",
+        "payloadCodecVersion",
+      ),
+    )
+    .returning({ id: schema.sessionEvents.id });
+  await db
+    .update(schema.sessions)
+    .set({
+      status: preclaim ? "queued" : "recovering",
+      activeTurnId: preclaim ? null : turn.id,
+      admissionBlock: null,
+      lastSequence: session.lastSequence + 2,
+      queueVersion: session.queueVersion + 1,
+      updatedAt: now,
+    })
+    .where(eq(schema.sessions.id, sessionId));
+  await registerSessionWorkflowWakeInTransaction(db, {
+    accountId,
+    workspaceId,
+    sessionId,
+    temporalWorkflowId: session.temporalWorkflowId ?? `session-${sessionId}`,
+    reason: "human_failed_session_retry",
+  });
+  const response = { outcome: "accepted", turnId: turn.id, failureEventId: failure.id } as const;
+  await updateSessionCommandReceiptResult(db, reserved.receipt.id, { result: response });
+  return { ...response, eventIds: events.map((event) => event.id) };
+}

package/src/skill-config-migration.ts

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import {
-  StoredCapabilityPack,
   StoredSessionSkills,
+  StoredAutomationSessionTemplate,
   validateSkillTextFiles,
   type SkillFile,
 } from "@opengeni/contracts";
@@ -74,7 +74,16 @@ export function convertLegacyPackConfig(value: unknown, identity: string): Objec
         },
       };
     });
-  StoredCapabilityPack.parse(converted);
+  // Historical migration 0433 only: validate the execution fields this
+  // conversion rewrites. The remaining archived manifest is opaque evidence,
+  // not an active capability or an admission contract.
+  if (converted.skills !== undefined) StoredSessionSkills.parse(converted.skills);
+  if (converted.automationTemplates !== undefined) {
+    if (!Array.isArray(converted.automationTemplates))
+      throw new Error("Expected historical automation template array");
+    for (const entry of converted.automationTemplates)
+      StoredAutomationSessionTemplate.parse(object(entry).sessionTemplate);
+  }
   return converted;
 }
 

package/src/skill-source-release-impact.ts

@@ -0,0 +1,33 @@
+export type SkillSourceReleaseHead = {
+  id: string;
+  account_id: string;
+  scope: string;
+  scope_workspace_id: string | null;
+  scope_version: number;
+  status: string;
+  active_revision_id: string | null;
+  provenance_source: string | null;
+  title: string | null;
+};
+
+type SkillRetentionReason = "customized" | "re_scoped";
+
+/** One decision for both the user-visible impact and committed source release. */
+export function classifySkillSourceRelease(
+  head: SkillSourceReleaseHead,
+  workspaceId: string,
+): {
+  disposition: "inactive" | "retained" | "removed";
+  retentionReasons: SkillRetentionReason[];
+} {
+  if (head.status !== "active" || !head.active_revision_id)
+    return { disposition: "inactive", retentionReasons: [] };
+  const retentionReasons: SkillRetentionReason[] = [];
+  if (head.provenance_source !== "portable_skill") retentionReasons.push("customized");
+  if (head.scope !== "workspace" || head.scope_workspace_id !== workspaceId)
+    retentionReasons.push("re_scoped");
+  return {
+    disposition: retentionReasons.length ? "retained" : "removed",
+    retentionReasons,
+  };
+}

package/src/skill-source-release.ts

@@ -2,6 +2,10 @@ import type { SkillActor } from "@opengeni/contracts";
 import { sql } from "drizzle-orm";
 import { rawRows, withWorkspaceSubjectRls, type Database } from "./database";
 import { deactivatePreferenceRegistry } from "./preference-registry";
+import {
+  classifySkillSourceRelease,
+  type SkillSourceReleaseHead,
+} from "./skill-source-release-impact";
 
 export type SkillSourceReleaseReceipt = {
   skillId: string;
@@ -11,6 +15,31 @@ export type SkillSourceReleaseReceipt = {
   warning: string | null;
 };
 
+/** Caller supplies workspace/subject RLS; never bypass registry visibility for a preview. */
+export async function readSkillSourceReleaseHeads(
+  db: Database,
+  workspaceId: string,
+  facetInstallationIds: readonly string[],
+): Promise<SkillSourceReleaseHead[]> {
+  if (!facetInstallationIds.length) return [];
+  return rawRows<SkillSourceReleaseHead>(
+    db,
+    sql`
+    SELECT DISTINCT h.id,h.account_id,h.scope,h.scope_workspace_id,h.scope_version,
+      h.status,h.active_revision_id,r.provenance_source,r.title
+    FROM skill_source_bindings b
+    JOIN capability_facet_installations fi ON fi.facet_id=b.skill_facet_id
+      AND fi.account_id=b.account_id AND fi.workspace_id=b.workspace_id
+    JOIN preference_registry_preferences h ON h.id=b.preference_id AND h.account_id=b.account_id
+    LEFT JOIN preference_registry_revisions r ON r.id=h.active_revision_id
+      AND r.preference_id=h.id AND r.account_id=h.account_id
+    WHERE b.workspace_id=${workspaceId}::uuid
+      AND fi.id=ANY(string_to_array(${facetInstallationIds.join(",")},',')::uuid[])
+    ORDER BY h.id
+  `,
+  );
+}
+
 export class SkillSourceRemovalAuthorityError extends Error {
   readonly code = "skill_source_removal_requires_human";
   constructor() {
@@ -21,6 +50,14 @@ export class SkillSourceRemovalAuthorityError extends Error {
   }
 }
 
+/** Never disclose the identity of a head absent from the caller's locked snapshot. */
+export class SkillSourceReleaseSnapshotChangedError extends Error {
+  constructor() {
+    super("Skill source visibility changed during removal; review a refreshed preview.");
+    this.name = "SkillSourceReleaseSnapshotChangedError";
+  }
+}
+
 /**
  * Called inside the source-owner removal transaction, with source installations
  * locked. Distribution identity/history stays bound after uninstall, so reinstall
@@ -28,7 +65,13 @@ export class SkillSourceRemovalAuthorityError extends Error {
  */
 export async function releaseOrphanedSkillHeads(
   db: Database,
-  input: { workspaceId: string; facetInstallationIds: readonly string[]; skillActor?: SkillActor },
+  input: {
+    workspaceId: string;
+    facetInstallationIds: readonly string[];
+    skillActor?: SkillActor;
+    /** Exact heads already locked before the caller compared removal impact. */
+    lockedHeadIds?: readonly string[];
+  },
 ): Promise<SkillSourceReleaseReceipt[]> {
   if (!input.facetInstallationIds.length) return [];
   const bindings = await rawRows<{ id: string }>(
@@ -48,35 +91,37 @@ export async function releaseOrphanedSkillHeads(
     throw new SkillSourceRemovalAuthorityError();
   }
   return withWorkspaceSubjectRls(db, input.workspaceId, actor.subjectId, async (tx) => {
+    const visibleHeads = await readSkillSourceReleaseHeads(
+      tx,
+      input.workspaceId,
+      input.facetInstallationIds,
+    );
+    const lockedHeadIds = new Set(input.lockedHeadIds ?? visibleHeads.map((head) => head.id));
+    if (visibleHeads.some((head) => !lockedHeadIds.has(head.id)))
+      throw new SkillSourceReleaseSnapshotChangedError();
     // The established definer lock capability accepts at most two heads; acquire
     // individual heads in canonical order rather than widening its authority.
-    for (const binding of bindings) {
+    // An inaccessible re-scoped head is preserved, never an excuse to acquire
+    // authority over another scope or disclose its identity in a receipt.
+    for (const binding of input.lockedHeadIds === undefined ? visibleHeads : []) {
       await tx.execute(
         sql`SELECT preference_id FROM preference_registry_lock_heads(ARRAY[${binding.id}::uuid])`,
       );
     }
-    const rows = await rawRows<{
-      id: string;
-      account_id: string;
-      scope: string;
-      scope_workspace_id: string | null;
-      scope_version: number;
-      status: string;
-      active_revision_id: string | null;
-      provenance_source: string | null;
-    }>(
+    const rows = await readSkillSourceReleaseHeads(
       tx,
-      sql`
-      SELECT h.id,h.account_id,h.scope,h.scope_workspace_id,h.scope_version,h.status,h.active_revision_id,r.provenance_source
-      FROM preference_registry_preferences h LEFT JOIN preference_registry_revisions r
-        ON r.id=h.active_revision_id AND r.preference_id=h.id AND r.account_id=h.account_id
-      WHERE h.id=ANY(string_to_array(${bindings.map((binding) => binding.id).join(",")},',')::uuid[])
-      ORDER BY h.id
-    `,
+      input.workspaceId,
+      input.facetInstallationIds,
     );
+    // A second subject may have moved a previously invisible head into this
+    // scope since either read. Never widen the locked set or acquire a new head
+    // lock out of canonical order during cleanup.
+    if (rows.some((head) => !lockedHeadIds.has(head.id)))
+      throw new SkillSourceReleaseSnapshotChangedError();
     const receipts: SkillSourceReleaseReceipt[] = [];
     for (const head of rows) {
-      if (head.status !== "active" || !head.active_revision_id) {
+      const impact = classifySkillSourceRelease(head, input.workspaceId);
+      if (impact.disposition === "inactive") {
         receipts.push({
           skillId: head.id,
           revisionId: head.active_revision_id,
@@ -84,11 +129,7 @@ export async function releaseOrphanedSkillHeads(
           eventId: null,
           warning: null,
         });
-      } else if (
-        head.provenance_source !== "portable_skill" ||
-        head.scope !== "workspace" ||
-        head.scope_workspace_id !== input.workspaceId
-      ) {
+      } else if (impact.disposition === "retained") {
         receipts.push({
           skillId: head.id,
           revisionId: head.active_revision_id,
@@ -103,7 +144,7 @@ export async function releaseOrphanedSkillHeads(
           actorSubjectId: actor.subjectId,
           principalKind: actor.principalKind,
           preferenceId: head.id,
-          expectedCurrentRevisionId: head.active_revision_id,
+          expectedCurrentRevisionId: head.active_revision_id!,
           expectedScopeVersion: head.scope_version,
           authorizeScope: (scope) => {
             if (scope !== "workspace")

package/src/skills.ts

@@ -88,12 +88,13 @@ export async function applySkillLifecycle(
           );
       }
     }
-    if (content === undefined) throw new Error("Skill lifecycle requires a readable SKILL.md");
-    const metadata = readSkillMetadata(content);
+    const removing = request.operation === "remove" || Boolean(request.removalOperationId);
+    if (content === undefined && !removing)
+      throw new Error("Skill lifecycle requires a readable SKILL.md");
+    const metadata = removing ? null : readSkillMetadata(content!);
     const canonicalRequest = {
       ...request,
-      title: metadata.name,
-      description: metadata.description,
+      ...(metadata ? { title: metadata.name, description: metadata.description } : {}),
     };
     const rows = await rawRows<{ receipt: SkillWriteReceipt }>(
       tx,
@@ -117,6 +118,30 @@ export type SkillReadContext = {
   subjectId?: string;
 };
 
+/** Scope only, for authorizing an exact human deletion retry after the head is gone.
+ * The lifecycle still verifies the complete request fingerprint before replay.
+ */
+export async function readSkillRemovalScope(
+  db: Database,
+  context: SkillReadContext & { subjectId: string },
+  skillId: string,
+  operationId: string,
+): Promise<"workspace" | "user" | null> {
+  return withWorkspaceSubjectRls(db, context.workspaceId, context.subjectId, async (tx) => {
+    const [row] = await rawRows<{ scope: string }>(
+      tx,
+      sql`
+      SELECT receipt->>'removedScope' AS scope FROM skill_write_receipts
+      WHERE account_id=${context.accountId}::uuid AND workspace_id=${context.workspaceId}::uuid
+        AND operation_id=${operationId}::uuid AND receipt->>'skillId'=${skillId}
+        AND receipt->>'removed'='true' AND actor->>'kind'='human'
+        AND actor->>'principalKind'='human_session' AND actor->>'subjectId'=${context.subjectId}
+    `,
+    );
+    return row?.scope === "workspace" || row?.scope === "user" ? row.scope : null;
+  });
+}
+
 /** Recheck the host-bound attempt before any agent-facing Skill read/search. */
 export async function assertSkillReadAttempt(
   db: Database,
@@ -212,6 +237,7 @@ export async function listSkillRecords(
             AND active.account_id=h.account_id AND active.expires_at <= transaction_timestamp()
         ) THEN 'expired' ELSE h.status END,
         'activeRevisionId',h.active_revision_id,'revisionId',r.id,
+        'removalOperationId',r.skill_removal_operation_id,
         'activationMode',coalesce(r.skill_activation_mode,'workspace_managed'),
         'pendingRevisionIds',coalesce((SELECT jsonb_agg(DISTINCT pending.receipt->>'revisionId')
           FROM skill_write_receipts pending WHERE pending.account_id=h.account_id
@@ -346,7 +372,7 @@ export async function skillReviewResolution(
   db: Database,
   context: SkillReadContext,
   review: SkillReviewReference,
-): Promise<"pending" | "activated" | "declined" | "superseded" | "unavailable"> {
+): Promise<"pending" | "activated" | "removed" | "declined" | "superseded" | "unavailable"> {
   const run = async (tx: Database) => {
     const [record] = await listSkillRecords(tx, context, {
       skillId: review.skillId,
@@ -354,7 +380,19 @@ export async function skillReviewResolution(
       metadataOnly: true,
       limit: 1,
     });
-    if (!record) return "unavailable" as const;
+    if (!record) {
+      if (review.removalOperationId) {
+        const [removed] = await rawRows<{ operation_id: string }>(
+          tx,
+          sql`
+          SELECT operation_id FROM skill_write_receipts
+          WHERE account_id=${context.accountId}::uuid AND workspace_id=${context.workspaceId}::uuid
+            AND receipt->>'skillId'=${review.skillId} AND receipt->>'removed'='true' LIMIT 1`,
+        );
+        if (removed) return "removed" as const;
+      }
+      return "unavailable" as const;
+    }
     const [event] = await rawRows<{ type: string }>(
       tx,
       sql`

package/src/user-resource-authority.ts

@@ -301,62 +301,6 @@ export async function issueSelfUserResourceGrant(
   });
 }
 
-export async function issueSelfLocalConnectionUseGrant(
-  db: Database,
-  input: {
-    accountId: string;
-    workspaceId: string;
-    subjectId: string;
-    authorityId: string;
-    context: "user_private" | "workspace_shared";
-    workspaceSharedAcknowledged: boolean;
-  },
-): Promise<UserResourceAuthorityGrant> {
-  return await withOwnerContext(db, input, async (scopedDb) => {
-    const [row] = await rawRows<
-      Omit<UserResourceAuthorityGrant, "delegation"> & {
-        organizationId: string;
-        authorityGeneration: number;
-      }
-    >(
-      scopedDb,
-      sql`
-        select grant_id as "grantId", organization_id as "organizationId",
-          authority_generation::int as "authorityGeneration",
-          target_workspace_id as "targetWorkspaceId",
-          target_session_id as "targetSessionId", action, grant_mode as mode,
-          grant_context as context, authority_epoch::int as "authorityEpoch",
-          grant_generation::int as generation, grant_status as status,
-          expires_at::text as "expiresAt"
-        from issue_self_local_connection_use_grant(
-          ${input.accountId}::uuid, ${input.authorityId}::uuid,
-          ${input.workspaceId}::uuid, ${input.context},
-          ${input.workspaceSharedAcknowledged}
-        )
-      `,
-    );
-    if (!row) throw new Error("local connection grant was not returned");
-    const { organizationId, authorityGeneration, ...grant } = row;
-    return {
-      ...grant,
-      expiresAt: rfc3339(grant.expiresAt),
-      delegation: {
-        authorityId: input.authorityId,
-        grantId: grant.grantId,
-        organizationId,
-        workspaceId: grant.targetWorkspaceId,
-        sessionId: grant.targetSessionId,
-        action: grant.action,
-        mode: grant.mode,
-        context: grant.context,
-        authorityEpoch: grant.authorityEpoch,
-        authorityGeneration,
-        grantGeneration: grant.generation,
-      },
-    };
-  });
-}
-
 export async function revokeSelfUserResourceGrant(
   db: Database,
   input: { accountId: string; workspaceId: string; subjectId: string; grantId: string },