@opengeni/core 0.20.16 → 0.21.10

package/dist/managed-session.d.ts

@@ -0,0 +1,53 @@
+import type { Context } from "hono";
+import type { ManagedAuth } from "./managed-auth-type";
+/**
+ * Read a Better Auth session without bypassing its sliding-cookie renewal.
+ *
+ * Better Auth can refresh the durable session while resolving `getSession`.
+ * Programmatic callers must explicitly request and forward the returned cookie
+ * headers; the HTTP handler does this automatically, but direct API calls do not.
+ */
+export declare function getManagedSession(c: Context, auth: ManagedAuth): Promise<{
+    session: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+    } | {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        userId: string;
+        expiresAt: Date;
+        token: string;
+        ipAddress?: string | null | undefined;
+        userAgent?: string | null | undefined;
+    };
+    user: {
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    } | {
+        [x: string]: any;
+        [x: number]: any;
+        [x: symbol]: any;
+        id: string;
+        createdAt: Date;
+        updatedAt: Date;
+        email: string;
+        emailVerified: boolean;
+        name: string;
+        image?: string | null | undefined;
+    };
+} | null>;

package/dist/sandbox/fleet.d.ts

@@ -1,7 +1,7 @@
 import type { Settings } from "@opengeni/config";
 import { type Database, type SandboxRecord } from "@opengeni/db";
 import type { EventBus } from "@opengeni/events";
-import { type BackendUnresolvableCode, type ControlRpc, type SelfhostedRelayConfig } from "@opengeni/runtime/sandbox";
+import { type BackendUnresolvableCode, type ControlRpc, type SelfhostedRelayConfig, type SelfhostedOpStreamDeps } from "@opengeni/runtime/sandbox";
 export type FleetServices = {
     db: Database;
     settings: Settings;
@@ -44,6 +44,7 @@ export declare function buildFleetContextForSession(deps: {
 }): Promise<FleetContext>;
 /** The dominant liveness of a fleet member, surfaced to the dock + the agent. */
 export type FleetLiveness = "online" | "reconnecting" | "offline";
+export type FleetOperationAvailability = "ready" | "wakeable" | "recovering" | "unavailable";
 /**
  * A fleet member as the agent + the dock see it (the M8b/M9 UI seam — the
  * `sandboxes_list` response entry the dock renders). STABLE shape: the dock keys
@@ -65,6 +66,11 @@ export type FleetSandboxEntry = {
     enrollmentId: string | null;
     /** Whether this target can be attached/swapped to right now (live + addressable). */
     attachable: boolean;
+    /** Whether an ordinary shell/files operation can use this target. This is
+     * deliberately separate from `attachable`: an idle managed home sandbox can
+     * be wakeable even while its holderless lease is cold/draining and therefore
+     * not an already-live swap target. */
+    operationAvailability: FleetOperationAvailability;
     /** Selfhosted only: whether whole-machine + screen-control consent is acked. */
     consented?: boolean;
     /** Selfhosted only: whether a display (real/Xvfb) is present. */
@@ -154,6 +160,8 @@ export type RunOnSelfhostedMachine = {
     controlTimeoutMs: number;
     /** Longer agent-side process deadline for exec. */
     execTimeoutMs: number;
+    /** Streaming transport required when execTimeoutMs is 0 (unbounded). */
+    opStream?: SelfhostedOpStreamDeps;
 };
 /**
  * Execute the one-off machine operation once the workspace/enrollment lookup has

package/dist/session-authorization.d.ts

@@ -1,4 +1,5 @@
 import { SessionAuthorizationActor, SessionAuthorizationListScope, type AccessGrant, type SessionAuthorizationOperation, type SessionAuthorizationSurface, type SessionAuthorizationTarget } from "@opengeni/contracts";
+import { type Database } from "@opengeni/db";
 import type { AppDependencies } from "./dependencies";
 export type SessionAuthorizationDependencies = Pick<AppDependencies, "db" | "sessionAuthorization">;
 /** Maximum time an omitted host hint leaves a live session stream unchecked. */
@@ -18,6 +19,14 @@ export type ResolvedSessionAuthorization = {
     relatedSessionAccess: "target" | "root";
     reauthorizeAfterMs: number | null;
 };
+/**
+ * Prove that a first-party request belongs to the exact currently active
+ * attempt of the named caller session. Unlike the optional embedding-host ACL
+ * port, this database fence is mandatory for high-trust operations.
+ */
+export declare function requireLiveAgentAttemptAuthorization(db: Database, grant: AccessGrant, callerSessionId: string): Promise<Extract<SessionAuthorizationActor, {
+    kind: "agent_attempt";
+}>>;
 /**
  * Resolve and enforce the host ACL for one session. The target and agent actor
  * are reconstructed from workspace-scoped durable state. A request can supply

package/dist/transcription.d.ts

@@ -1,4 +1,13 @@
 import type { TranscribeAudioResponse, VoiceInputErrorCode } from "@opengeni/contracts";
+/**
+ * Server-owned upstream budget for one provider attempt. Resumable recording
+ * claims remain fenced for longer than this budget before another worker may
+ * reclaim them. Provider adapters must honor the supplied AbortSignal and must
+ * not return while their upstream request is still live; OpenGeni does not
+ * claim remote-side idempotency or cancellation for vendors that cannot meet
+ * that adapter contract.
+ */
+export declare const TRANSCRIPTION_PROVIDER_REQUEST_TIMEOUT_MILLISECONDS: number;
 export type TranscriptionLimits = {
     maxDurationSeconds: number;
     maxSizeBytes: number;
@@ -13,6 +22,10 @@ export type TranscriptionRequest = {
     durationSeconds?: number | undefined;
     signal?: AbortSignal | undefined;
     requestId: string;
+    /** Absolute server-owned provider deadline persisted for resumable attempts. */
+    providerDeadlineAt?: Date | undefined;
+    /** Exact provider selected before a resumable segment is first sent upstream. */
+    providerId?: string | undefined;
 };
 export type TranscriptionResult = TranscribeAudioResponse & {
     /** Server-private provider id for operational metrics only. Never returned to clients. */
@@ -43,6 +56,8 @@ export type TranscriptionAvailabilityContext = {
  */
 export type TranscriptionProvider = {
     readonly id: string;
+    /** The adapter guarantees that its upstream transport honors AbortSignal. */
+    readonly supportsServerDeadline: true;
     readonly experimental?: boolean | undefined;
     /**
      * Deployment readiness when called without a workspace. When `workspaceId` is
@@ -54,6 +69,7 @@ export type TranscriptionProvider = {
         mimeType: string;
         filename: string;
         workspaceId: string;
+        requestId: string;
         signal?: AbortSignal | undefined;
     }): Promise<{
         text: string;
@@ -64,8 +80,27 @@ export type TranscriptionService = {
     limits(): TranscriptionLimits;
     /** True when at least one ready provider can serve requests. */
     available(context?: TranscriptionAvailabilityContext): boolean | Promise<boolean>;
+    /** Select one provider before a durable segment attempt; retries pin this id. */
+    selectProvider?(context: TranscriptionAvailabilityContext): string | null | Promise<string | null>;
     transcribe(request: TranscriptionRequest): Promise<TranscriptionResult>;
 };
+export type PreparedTranscriptionSegment = {
+    segmentNumber: number;
+    startMilliseconds: number;
+    durationMilliseconds: number;
+    mimeType: "audio/wav";
+    bytes: Uint8Array;
+};
+export type TranscriptionSegmenter = {
+    available(): boolean | Promise<boolean>;
+    segment(input: {
+        sourceMimeType: string;
+        totalDurationMilliseconds: number;
+        providerSegmentSeconds: number;
+        chunks: AsyncIterable<Uint8Array>;
+        signal?: AbortSignal | undefined;
+    }): AsyncIterable<PreparedTranscriptionSegment>;
+};
 export declare function normalizeMimeType(mimeType: string): string;
 export declare function isAcceptedMimeType(mimeType: string, accepted: readonly string[]): boolean;
 export declare function filenameForMimeType(mimeType: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/core",
-  "version": "0.20.16",
+  "version": "0.21.10",
   "description": "OpenGeni framework-agnostic core: the domain, access, and billing layers (neutral access, off-HTTP V2 surface). Behavior-preserving extraction from apps/api — keeps Hono's HTTPException for error throwing (typed-errors cleanup deferred).",
   "license": "Apache-2.0",
   "repository": {
@@ -34,15 +34,15 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
-    "@opengeni/codex": "^0.2.11",
-    "@opengeni/config": "^0.10.14",
-    "@opengeni/contracts": "^0.38.3",
-    "@opengeni/db": "^0.27.11",
-    "@opengeni/documents": "^0.5.7",
-    "@opengeni/events": "^0.3.77",
-    "@opengeni/observability": "^0.4.16",
-    "@opengeni/runtime": "^0.18.15",
-    "@opengeni/storage": "^0.2.67",
+    "@opengeni/codex": "^0.2.13",
+    "@opengeni/config": "^0.12.1",
+    "@opengeni/contracts": "^0.40.0",
+    "@opengeni/db": "^0.28.9",
+    "@opengeni/documents": "^0.5.18",
+    "@opengeni/events": "^0.3.88",
+    "@opengeni/observability": "^0.5.6",
+    "@opengeni/runtime": "^0.18.24",
+    "@opengeni/storage": "^0.2.75",
     "hono": "^4.12.18"
   },
   "engines": {

package/src/access/index.ts

@@ -17,6 +17,7 @@ import {
 import type { Context } from "hono";
 import { HTTPException } from "hono/http-exception";
 import type { ManagedAuth } from "../managed-auth-type";
+import { getManagedSession } from "../managed-session";
 
 const bearerPrefix = "Bearer ";
 
@@ -143,10 +144,51 @@ export function requirePermission(grant: AccessGrant, permission: Permission): v
   }
 }
 
+/**
+ * Require a permission to be present literally on the grant. This deliberately
+ * does not expand workspace:admin or deprecated aliases and is reserved for
+ * authorities, such as plaintext secret reads, that old broad grants must not
+ * acquire implicitly.
+ */
+export function requireLiteralPermission(grant: AccessGrant, permission: Permission): void {
+  if (!hasLiteralPermission(grant.permissions, permission)) {
+    throw new HTTPException(403, {
+      message: `missing literal permission: ${permission}`,
+    });
+  }
+}
+
+export function hasLiteralPermission(permissions: Permission[], permission: Permission): boolean {
+  return permissions.includes(permission);
+}
+
 export function hasPermission(permissions: Permission[], permission: Permission): boolean {
+  if (permission === "secrets:read") {
+    return permissions.includes("secrets:read");
+  }
   const aliases: Partial<Record<Permission, Permission[]>> = {
     "variable-sets:use": ["environments:use" as Permission],
     "variable-sets:manage": ["environments:manage" as Permission],
+    "variable-sets:list": [
+      "variable-sets:use",
+      "variable-sets:manage",
+      "environments:use" as Permission,
+      "environments:manage" as Permission,
+    ],
+    "variable-sets:read": [
+      "variable-sets:use",
+      "variable-sets:manage",
+      "environments:use" as Permission,
+      "environments:manage" as Permission,
+    ],
+    "variable-sets:write": ["variable-sets:manage", "environments:manage" as Permission],
+    "secrets:list": [
+      "variable-sets:use",
+      "variable-sets:manage",
+      "environments:use" as Permission,
+      "environments:manage" as Permission,
+    ],
+    "secrets:write": ["variable-sets:manage", "environments:manage" as Permission],
   };
   return (
     permissions.includes(permission) ||
@@ -210,9 +252,7 @@ async function resolveAccessContext(c: Context, deps: AccessDeps): Promise<Acces
   }
 
   if (deps.managedAuth) {
-    const session = await deps.managedAuth.api.getSession({
-      headers: c.req.raw.headers,
-    });
+    const session = await getManagedSession(c, deps.managedAuth);
     if (session?.user) {
       return await ensureManagedAccessForUser(deps.db, {
         userId: session.user.id,

package/src/application/session-commands.ts

@@ -46,6 +46,7 @@ import {
   type EventBus,
 } from "@opengeni/events";
 import type { SessionWorkflowClient } from "../dependencies";
+import { normalizeResources } from "../domain/resources";
 import {
   requireSessionAuthorization,
   type ResolvedSessionAuthorization,
@@ -200,10 +201,14 @@ async function publishAndWakeAgentCommand(
         ? { interruptionRequested: true }
         : {}),
     });
-  } catch (error) {
+  } catch {
     console.warn(
-      `[session-commands] immediate Agent command wake failed for ${input.workspaceId}/${input.sessionId}; durable outbox will retry`,
-      error,
+      "[session-commands] immediate Agent command wake failed; durable outbox will retry",
+      {
+        errorClass: "WorkflowWakeOperationError",
+        errorCode: "agent_command_wake_failed",
+        origin: "core",
+      },
     );
   }
 }
@@ -222,10 +227,15 @@ async function requestControlWakeDispatch(
   if (wakeCount === 0) return;
   try {
     await deps.workflowClient.requestSessionWorkflowWakeDispatch();
-  } catch (error) {
+  } catch {
     console.warn(
-      `[session-commands] immediate control wake dispatch failed for ${wakeCount} committed revisions; durable outbox will retry`,
-      error,
+      "[session-commands] immediate control wake dispatch failed; durable outbox will retry",
+      {
+        errorClass: "WorkflowWakeOperationError",
+        errorCode: "control_wake_dispatch_failed",
+        origin: "core",
+        wakeCount,
+      },
     );
   }
 }
@@ -565,7 +575,7 @@ export async function steerHumanQueuePrompt(
   return response;
 }
 
-export async function controlHumanSessionWorkstream(
+export async function controlHumanSessionWorkstreamWithOutcome(
   deps: {
     db: Database;
     bus: EventBus;
@@ -574,7 +584,7 @@ export async function controlHumanSessionWorkstream(
   },
   context: HumanSessionCommandContext,
   input: SessionControlRequest,
-): Promise<SessionControlResponse> {
+): Promise<{ response: SessionControlResponse; replay: boolean }> {
   const authorization = await authorizeHumanSessionCommand(deps, context, "session.control");
   const result = await withWorkspaceRls(deps.db, context.workspaceId, (scoped) =>
     scoped.transaction((tx) =>
@@ -607,7 +617,16 @@ export async function controlHumanSessionWorkstream(
   }
   await publishWorkspaceControlEvent(deps, context.workspaceId, result.workspaceControlEventId);
   await requestControlWakeDispatch(deps, result.wakeCount);
-  return response;
+  return { response, replay: result.replay };
+}
+
+/** Backward-compatible response path used by the REST control route. */
+export async function controlHumanSessionWorkstream(
+  deps: Parameters<typeof controlHumanSessionWorkstreamWithOutcome>[0],
+  context: Parameters<typeof controlHumanSessionWorkstreamWithOutcome>[1],
+  input: Parameters<typeof controlHumanSessionWorkstreamWithOutcome>[2],
+): Promise<SessionControlResponse> {
+  return (await controlHumanSessionWorkstreamWithOutcome(deps, context, input)).response;
 }
 
 export async function controlHumanWorkspace(
@@ -692,6 +711,7 @@ export async function saveHumanComposerDraft(
         saveComposerDraftInTransaction(tx as unknown as Database, {
           ...context,
           ...input,
+          resources: normalizeResources(input.resources),
           subjectId: context.subjectId,
         }),
       ),

package/src/dependencies.ts

@@ -15,7 +15,7 @@ import type { Observability } from "@opengeni/observability";
 import type { createObjectStorage } from "@opengeni/storage";
 import type { ManagedAuth } from "./managed-auth-type";
 import type { ApiSandboxClient, ResumeBoxByIdInput, ResumedSandboxSession } from "./sandbox-types";
-import type { TranscriptionService } from "./transcription";
+import type { TranscriptionSegmenter, TranscriptionService } from "./transcription";
 
 export type SessionWorkflowClient = {
   signalUserMessage: (input: {
@@ -123,6 +123,8 @@ export type AppDependencies = {
   oauthCallbackDeadlineMs?: number;
   /** Optional host-owned voice-input transcription service. */
   transcription?: TranscriptionService | null;
+  /** Optional host-owned long-form audio normalization/segmentation service. */
+  transcriptionSegmenter?: TranscriptionSegmenter | null;
   // The API process's OWN agent-loop-free sandbox client (constructed from
   // settings via @opengeni/runtime/sandbox). Undefined when sandboxBackend=none.
   // This is the foundation of the API-direct control plane: the API resumes

package/src/domain/capabilities.ts

@@ -85,6 +85,7 @@ export async function buildCapabilityCatalog(input: {
     socialConnections,
     bundledSkills,
     curatedLibrarySkills,
+    codexAppsCredentialId,
   ] = await Promise.all([
     listCapabilityCatalogItems(input.db, input.workspaceId),
     listCapabilityInstallations(input.db, input.workspaceId),
@@ -93,6 +94,9 @@ export async function buildCapabilityCatalog(input: {
     listSocialConnections(input.db, input.workspaceId, 500, input.subjectId),
     discoverBundledSkills(),
     discoverCuratedSkillLibraryItems(),
+    input.settings.codexConnectedAppsEnabled
+      ? resolveCodexAppsCredentialIdForRun(input.db, input.workspaceId)
+      : Promise.resolve(null),
   ]);
   const capabilityInstallationById = new Map(
     capabilityInstallations.map((installation) => [installation.capabilityId, installation]),
@@ -112,7 +116,16 @@ export async function buildCapabilityCatalog(input: {
     ...bundledSkills,
     ...curatedLibrarySkills,
   ];
-  const items = dedupeCatalogItems([...builtIns, ...persistedItems])
+  const codexApps = input.settings.codexConnectedAppsEnabled
+    ? codexAppsCatalogItem(codexAppsCredentialId !== null)
+    : null;
+  const items = dedupeCatalogItems([
+    ...builtIns,
+    ...persistedItems.filter((item) => !isReservedCodexAppsCatalogItem(item)),
+    // Keep the reserved, server-derived item authoritative over any stale
+    // legacy catalog row with the same id.
+    ...(codexApps ? [codexApps] : []),
+  ])
     .map((item) =>
       applyCapabilityEnablement(item, capabilityInstallationById.get(item.id), activePackIds),
     )
@@ -142,8 +155,9 @@ export async function createCatalogItem(input: {
   }
   if (
     input.payload.kind === "mcp" &&
-    typeof input.payload.metadata.mcpServerId === "string" &&
-    input.payload.metadata.mcpServerId.trim() === CODEX_APPS_MCP_SERVER_ID
+    (id === `mcp:${CODEX_APPS_MCP_SERVER_ID}` ||
+      (typeof input.payload.metadata.mcpServerId === "string" &&
+        input.payload.metadata.mcpServerId.trim() === CODEX_APPS_MCP_SERVER_ID))
   ) {
     throw new HTTPException(422, {
       message: `${CODEX_APPS_MCP_SERVER_ID} is reserved for the canonical Codex Apps service`,
@@ -997,34 +1011,84 @@ function packCatalogItem(
 }
 
 function configuredMcpCatalogItems(settings: Settings): CapabilityCatalogItem[] {
-  return settings.mcpServers.map((server) =>
-    CapabilityCatalogItem.parse({
-      id: `mcp:${server.id}`,
-      kind: "mcp",
-      source: firstPartyMcpServerIds.has(server.id) ? "built_in" : "configured",
-      name: server.name ?? server.id,
-      description: firstPartyMcpDescription(server.id),
-      category: firstPartyMcpServerIds.has(server.id) ? "platform" : "configured",
-      tags: ["mcp", ...(server.allowedTools?.length ? ["limited-tools"] : [])],
-      endpointUrl: server.url,
-      tools: [{ kind: "mcp", id: server.id }],
-      runtime: {
-        available: true,
-        mcpServerId: server.id,
-        transport: "streamable-http",
-        notes: firstPartyMcpServerIds.has(server.id)
-          ? "Available from OpenGeni runtime configuration."
-          : "Configured through OPENGENI_MCP_SERVERS.",
-      },
-      metadata: {
-        mcpServerId: server.id,
-        allowedTools: server.allowedTools ?? [],
-        cacheToolsList: server.cacheToolsList,
-      },
-    }),
+  return settings.mcpServers
+    .filter((server) => server.id !== CODEX_APPS_MCP_SERVER_ID)
+    .map((server) =>
+      CapabilityCatalogItem.parse({
+        id: `mcp:${server.id}`,
+        kind: "mcp",
+        source: firstPartyMcpServerIds.has(server.id) ? "built_in" : "configured",
+        name: server.name ?? server.id,
+        description: firstPartyMcpDescription(server.id),
+        category: firstPartyMcpServerIds.has(server.id) ? "platform" : "configured",
+        tags: ["mcp", ...(server.allowedTools?.length ? ["limited-tools"] : [])],
+        endpointUrl: server.url,
+        tools: [{ kind: "mcp", id: server.id }],
+        runtime: {
+          available: true,
+          mcpServerId: server.id,
+          transport: "streamable-http",
+          notes: firstPartyMcpServerIds.has(server.id)
+            ? "Available from OpenGeni runtime configuration."
+            : "Configured through OPENGENI_MCP_SERVERS.",
+        },
+        metadata: {
+          mcpServerId: server.id,
+          allowedTools: server.allowedTools ?? [],
+          cacheToolsList: server.cacheToolsList,
+        },
+      }),
+    );
+}
+
+function isReservedCodexAppsCatalogItem(item: CapabilityCatalogItem): boolean {
+  return (
+    item.id === `mcp:${CODEX_APPS_MCP_SERVER_ID}` ||
+    (item.kind === "mcp" &&
+      (item.runtime.mcpServerId === CODEX_APPS_MCP_SERVER_ID ||
+        item.metadata.mcpServerId === CODEX_APPS_MCP_SERVER_ID))
   );
 }
 
+/**
+ * The Apps MCP is not a configured server and is not a user-installable
+ * capability. It is a deployment-gated, workspace-designated runtime surface,
+ * so project it into the same catalog the web picker already consumes while
+ * keeping its authorization state server-derived and explicit.
+ */
+export function codexAppsCatalogItem(available: boolean): CapabilityCatalogItem {
+  return CapabilityCatalogItem.parse({
+    id: `mcp:${CODEX_APPS_MCP_SERVER_ID}`,
+    kind: "mcp",
+    source: "built_in",
+    name: "Codex Apps",
+    description:
+      "Use the ChatGPT Apps designated for this workspace. Sessions include this surface by default when it is authorized; explicit policies can opt out.",
+    category: "productivity",
+    tags: ["mcp", "codex", "connected-apps"],
+    providerDomain: "chatgpt.com",
+    surfaceType: "codex_apps",
+    transport: "streamable-http",
+    mcpUrl: CODEX_APPS_MCP_URL,
+    authKind: "none",
+    tools: [{ kind: "mcp", id: CODEX_APPS_MCP_SERVER_ID }],
+    runtime: {
+      available,
+      ...(available ? { mcpServerId: CODEX_APPS_MCP_SERVER_ID } : {}),
+      transport: "streamable-http",
+      notes: available
+        ? "Available through the active workspace Apps designation."
+        : "Unavailable until an active Codex Apps credential is designated for this workspace.",
+    },
+    enabled: available,
+    enabledReason: available ? "designated Apps credential" : "no active Apps designation",
+    metadata: {
+      mcpServerId: CODEX_APPS_MCP_SERVER_ID,
+      authorization: "workspace_designation",
+    },
+  });
+}
+
 function platformApiCatalogItems(socialConnections: SocialConnection[]): CapabilityCatalogItem[] {
   const xConnection = preferredSocialConnection(socialConnections, "x");
   const xEnabled = xConnection?.status === "connected" || xConnection?.status === "needs_reauth";
@@ -1276,6 +1340,12 @@ export function applyCapabilityEnablement(
     // connector is browseable, not that an account is already connected.
     return { ...item, connectionRef: null };
   }
+  if (item.surfaceType === "codex_apps") {
+    // Unlike ordinary built-ins, Apps availability is derived from the exact
+    // active workspace designation above. Do not overwrite it with the
+    // generic source-based "built in" enablement rule.
+    return { ...item, connectionRef: null };
+  }
   if (item.source === "built_in" || item.source === "configured") {
     return {
       ...item,
@@ -1606,7 +1676,7 @@ function capabilityInstallationRuntimeReady(
 }
 
 /**
- * Checks the redacted installation config (header names only) against the
+ * Checks the generic installation projection (header names only) against the
  * capability's declared credential requirements.
  */
 function storedCredentialHeadersSatisfy(

package/src/domain/memory-slack-publication.ts

@@ -1,6 +1,5 @@
 import { createHash } from "node:crypto";
 import {
-  redactSensitiveText,
   stableJson,
   type KnowledgeMemoryKind,
   type KnowledgeMemoryStatus,
@@ -109,13 +108,11 @@ export type MemorySlackPublicationProjection = {
   importance: MemorySlackImportance;
   deliveryMode: MemorySlackDeliveryMode;
   summary: string;
-  summaryRedacted: boolean;
   summaryTruncated: boolean;
   namespace: string;
   labels: string[];
   labelsTruncated: boolean;
   ownerLabel: string | null;
-  ownerLabelRedacted: boolean;
   ownerLabelTruncated: boolean;
   authoritativeRecord: {
     workspaceId: string;
@@ -201,9 +198,8 @@ export function evaluateMemorySlackPublication(
   if (!deliveryMode) return denied("below_noise_policy");
 
   const collapsedSummary = collapseText(input.distribution.shareSummary);
-  const redactedSummary = redactSensitiveText(collapsedSummary);
-  if (!redactedSummary) return denied("missing_summary");
-  const summary = truncateUtf8(redactedSummary, MEMORY_SLACK_SUMMARY_MAX_UTF8_BYTES);
+  if (!collapsedSummary) return denied("missing_summary");
+  const summary = truncateUtf8(collapsedSummary, MEMORY_SLACK_SUMMARY_MAX_UTF8_BYTES);
 
   const namespace = normalizeNamespace(input.memory.namespace);
   const labels = normalizeLabels(input.memory.labels);
@@ -221,13 +217,11 @@ export function evaluateMemorySlackPublication(
     importance: input.distribution.importance,
     deliveryMode,
     summary: summary.value,
-    summaryRedacted: redactedSummary !== collapsedSummary,
     summaryTruncated: summary.truncated,
     namespace,
     labels: labels.values,
     labelsTruncated: labels.truncated,
     ownerLabel: owner.value,
-    ownerLabelRedacted: owner.redacted,
     ownerLabelTruncated: owner.truncated,
     authoritativeRecord: {
       workspaceId: input.context.workspaceId,
@@ -368,10 +362,8 @@ function effectiveDeliveryMode(
 
 function normalizeNamespace(value: string): string | null {
   const trimmed = value.trim();
-  if (redactSensitiveText(trimmed) !== trimmed) return null;
   const namespace = trimmed.toLowerCase();
   if (!namespace || utf8Bytes(namespace) > MEMORY_SLACK_NAMESPACE_MAX_UTF8_BYTES) return null;
-  if (redactSensitiveText(namespace) !== namespace) return null;
   const segments = namespace.split("/");
   if (segments.some((segment) => !SELECTOR_SEGMENT_PATTERN.test(segment))) return null;
   return segments.join("/");
@@ -385,10 +377,8 @@ function normalizeLabels(
   for (const value of values) {
     if (typeof value !== "string") return null;
     const trimmed = value.trim();
-    if (redactSensitiveText(trimmed) !== trimmed) return null;
     const label = trimmed.toLowerCase();
     if (
-      redactSensitiveText(label) !== label ||
       !SELECTOR_SEGMENT_PATTERN.test(label) ||
       utf8Bytes(label) > MEMORY_SLACK_LABEL_MAX_UTF8_BYTES
     ) {
@@ -406,14 +396,12 @@ function normalizeLabels(
 function boundedOptionalText(
   value: string | null | undefined,
   maxBytes: number,
-): { value: string | null; redacted: boolean; truncated: boolean } {
+): { value: string | null; truncated: boolean } {
   const collapsed = collapseText(value ?? "");
-  if (!collapsed) return { value: null, redacted: false, truncated: false };
-  const redacted = redactSensitiveText(collapsed);
-  const bounded = truncateUtf8(redacted, maxBytes);
+  if (!collapsed) return { value: null, truncated: false };
+  const bounded = truncateUtf8(collapsed, maxBytes);
   return {
     value: bounded.value || null,
-    redacted: redacted !== collapsed,
     truncated: bounded.truncated,
   };
 }