@opengeni/core 2.10.0-canary.0 → 2.10.0-canary.2

package/src/domain/sessions.ts

@@ -1,7 +1,11 @@
+import { knowledgeContextForAccess } from "./knowledge";
+import { saveAgentLearningSettings } from "@opengeni/db";
+import { withSessionRlsActorContext } from "@opengeni/db";
+import { fileOwnerContextForAccess, fileOwnerContextForAgent } from "./file-owner";
 import { CODEX_MODEL_ID_PREFIX, isCodexBilledModel } from "@opengeni/codex";
 import { sessionCreationMetadata } from "../site-session-origin";
 import {
-  HostMcpBindingDefinition,
+  hostMcpBindingMatchesSelection,
   HostMcpCreateSelections,
   type HostMcpCreateSelection,
 } from "@opengeni/contracts/host-mcp-bindings";
@@ -30,6 +34,7 @@ import {
   CreateSessionRequest,
   DEFAULT_FIRST_PARTY_MCP_PERMISSIONS,
   DEFAULT_FIRST_PARTY_MCP_TOOLS,
+  currentAgentLearningToolSelection,
   DraftTimelineAnnotations,
   FIRST_PARTY_MCP_TOOL_NAMES,
   OPENGENI_SLACK_BOT_SESSION_METADATA_KEY,
@@ -272,8 +277,10 @@ export function effectiveFirstPartyMcpToolCeiling(
     allowed: readonly FirstPartyMcpToolName[];
   },
 ): Set<FirstPartyMcpToolName> {
-  const allowed = new Set(policy.allowed);
-  const ceiling = new Set([...(stored ?? policy.default)].filter((tool) => allowed.has(tool)));
+  const allowed = new Set(currentAgentLearningToolSelection(policy.allowed));
+  const ceiling = new Set(
+    currentAgentLearningToolSelection(stored ?? policy.default).filter((tool) => allowed.has(tool)),
+  );
   if (ceiling.has("goal_pause") && allowed.has("goal_resume")) ceiling.add("goal_resume");
   return ceiling;
 }
@@ -300,6 +307,7 @@ export function resolveFirstPartyMcpToolsForCreate(
   },
 ): FirstPartyMcpToolName[] {
   if (requested !== undefined) {
+    requested = currentAgentLearningToolSelection(requested);
     if (parentStored !== undefined) {
       const parentCeiling = effectiveFirstPartyMcpToolCeiling(parentStored, policy);
       const widened = requested.find((tool) => !parentCeiling.has(tool));
@@ -311,9 +319,9 @@ export function resolveFirstPartyMcpToolsForCreate(
     }
     return [...requested];
   }
-  const allowed = new Set(policy.allowed);
+  const allowed = new Set(currentAgentLearningToolSelection(policy.allowed));
   const inherited = parentStored === undefined ? policy.default : (parentStored ?? policy.default);
-  return [...inherited].filter((tool) => allowed.has(tool));
+  return currentAgentLearningToolSelection(inherited).filter((tool) => allowed.has(tool));
 }
 
 function sessionSpawnDeniedMessage(denial: SessionSpawnDenial): string {
@@ -738,6 +746,7 @@ function automaticTitleForAgentChildCreate(
 }
 
 export async function createAndStartSessionWithOutcome(input: {
+  initialAgentLearning?: import("@opengeni/contracts").AgentLearningOverrides | undefined;
   requestedSessionId?: string;
   db: Database;
   bus: EventBus;
@@ -1024,6 +1033,7 @@ export async function createAndStartSessionWithOutcome(input: {
       tools: input.tools,
       toolPolicy: input.toolPolicy,
       metadata: sessionMetadata,
+      initialAgentLearning: input.initialAgentLearning,
       selectedHostMcpDelegations: input.selectedHostMcpDelegations ?? [],
       ...(input.createdBy ? { createdBy: input.createdBy } : {}),
       ...(frozenCreatedByContext ? { createdByContext: frozenCreatedByContext } : {}),
@@ -1119,6 +1129,7 @@ export async function createAndStartSessionWithOutcome(input: {
       tools: input.tools,
       toolPolicy: input.toolPolicy,
       metadata: sessionMetadata,
+      initialAgentLearning: input.initialAgentLearning,
       ...(input.createdBy ? { createdBy: input.createdBy } : {}),
       selectedHostMcpDelegations: input.selectedHostMcpDelegations ?? [],
       ...(frozenCreatedByContext ? { createdByContext: frozenCreatedByContext } : {}),
@@ -2004,7 +2015,7 @@ async function withSessionCreateUsageRecording(input: {
   return { ...input.createOutcome, usageRecording };
 }
 
-export async function createSessionForRequestWithOutcome(
+async function createSessionForRequestInFileScope(
   unresolvedDeps: ApiRouteDeps,
   grant: AccessGrant,
   workspaceId: string,
@@ -2180,6 +2191,8 @@ export async function createSessionForRequestWithOutcome(
           : {}),
         createIdempotencyKey: payload.idempotencyKey,
         selectedInstalledSkillIds: payload.installedSkillIds ?? [],
+        initialAgentLearning: payload.agentLearning,
+        ...sessionScope,
         selectedHostMcpDelegations: hostSelections,
         ...(payload.requestedSessionId ? { requestedSessionId: payload.requestedSessionId } : {}),
         visibility: effectiveVisibility,
@@ -2455,7 +2468,21 @@ export async function createSessionForRequestWithOutcome(
       message: "object storage is not configured",
     });
   }
-  await validateFileResources(db, grant.accountId, workspaceId, grant.subjectId, resources);
+  await validateFileResources(
+    db,
+    grant.accountId,
+    workspaceId,
+    personalResourceSubjectId ?? grant.subjectId,
+    resources,
+    (authorization || grant.principalKind === "agent_attempt") &&
+      (effectiveVisibility === "user_private" ||
+        sessionScope.memoryScope === "user" ||
+        workspace.kind === "personal")
+      ? authorization
+        ? await fileOwnerContextForAccess({ db }, authorization, "sessions:create")
+        : await fileOwnerContextForAgent({ db }, grant, "sessions:create")
+      : undefined,
+  );
   // Every selected Variable Set is independently authorized. Scope does not
   // affect precedence: explicit order is low-to-high and later sets win name
   // collisions.
@@ -3016,6 +3043,46 @@ export async function createSessionForRequestWithOutcome(
       model,
     });
   }
+  const initialLearning =
+    payload.agentLearning && Object.keys(payload.agentLearning).length
+      ? payload.agentLearning
+      : null;
+  const initialLearningContext =
+    initialLearning && authorization
+      ? await knowledgeContextForAccess(deps, authorization, "sessions:control")
+      : null;
+  if (initialLearning && initialLearningContext?.actor.kind !== "human") {
+    throw new HTTPException(403, {
+      message: "Chat learning settings require authenticated human session control",
+    });
+  }
+  const initialLearningScope =
+    effectiveVisibility === "user_private" ||
+    sessionScope.memoryScope === "user" ||
+    workspace.kind === "personal"
+      ? ("personal" as const)
+      : ("workspace" as const);
+  const initialLearningActor = initialLearningContext?.actor;
+  const beforeCreateCommit =
+    initialLearning && initialLearningContext && initialLearningActor?.kind === "human"
+      ? async (tx: Database, sessionId: string) => {
+          await externalBeforeCreateCommit?.(tx);
+          await saveAgentLearningSettings(
+            tx,
+            {
+              ...initialLearningContext,
+              actor: { ...initialLearningActor, settingsScopes: [initialLearningScope] },
+            },
+            {
+              scope: initialLearningScope,
+              source: { kind: "chat", id: sessionId },
+              operationId: sessionId,
+              expectedVersion: 0,
+              settings: initialLearning,
+            },
+          );
+        }
+      : externalBeforeCreateCommit;
   let createOutcome: CreateSessionOutcome;
   try {
     createOutcome = await createAndStartSessionWithOutcome({
@@ -3050,7 +3117,7 @@ export async function createSessionForRequestWithOutcome(
       ...(effectiveSandboxOs ? { sandboxOs: effectiveSandboxOs } : {}),
       sandboxGroupId,
       metadata: creationMetadata ?? {},
-      ...(externalBeforeCreateCommit ? { beforeCreateCommit: externalBeforeCreateCommit } : {}),
+      ...(beforeCreateCommit ? { beforeCreateCommit } : {}),
       selectedHostMcpDelegations: hostSelections,
       ...(captureSelectedHostAuthority || captureLinkedAuthority
         ? {
@@ -3098,6 +3165,7 @@ export async function createSessionForRequestWithOutcome(
       parentSessionId,
       createIdempotencyKey: payload.idempotencyKey ?? null,
       selectedInstalledSkillIds,
+      initialAgentLearning: payload.agentLearning,
       maxNestedAgentDepthOverride: payload.maxNestedAgentDepth ?? null,
       allowNestedAgentDepthIncrease: hasPermission(grant.permissions, "workspace:admin"),
       subjectId: grant.subjectId,
@@ -3263,22 +3331,17 @@ function prepareSelectedHostTurnAuthority(
       const delegation = await getHostMcpDelegation(tx, owner, selection.delegationId);
       const binding = delegation ? await getHostMcpBinding(tx, owner, delegation.bindingId) : null;
       const configured = configs.get(selection.serverId)!;
-      const { hostBinding, ...connectionRef } = configured.connectionRef!;
-      const definition = HostMcpBindingDefinition.safeParse({
-        serverId: selection.serverId,
-        destinationUrl: configured.url,
-        connectionRef,
-      });
       if (
         !delegation ||
         !binding ||
         delegation.status !== "active" ||
         binding.status !== "active" ||
-        !definition.success ||
         delegation.generation !== selection.generation ||
-        binding.id !== hostBinding!.bindingId ||
-        binding.generation !== hostBinding!.generation ||
-        stableJson(definition.data) !== stableJson(binding.definition)
+        !hostMcpBindingMatchesSelection(binding, {
+          serverId: selection.serverId,
+          destinationUrl: configured.url!,
+          connectionRef: configured.connectionRef!,
+        })
       )
         throw new HTTPException(403, { message: "Host delegation selection changed" });
       try {
@@ -3357,7 +3420,7 @@ function sessionPromptBoundaryRequestHash(input: {
  * enqueue, and usage recording. `toolsProvided: false` durably preserves an
  * Tool selection is durable session state and never rides a follow-up prompt.
  */
-export async function acceptSessionUserMessageWithOutcome(
+async function acceptSessionUserMessageInFileScope(
   deps: AcceptSessionUserMessageDependencies,
   grant: AccessGrant,
   workspaceId: string,
@@ -3582,6 +3645,15 @@ export async function acceptSessionUserMessageWithOutcome(
       workspaceId,
       grant.subjectId,
       requestedResources,
+      (input.authorization || grant.principalKind === "agent_attempt") &&
+        ((await getSessionAuthorityProjection(db, workspaceId, sessionId))?.visibility ===
+          "user_private" ||
+          existingSession.memoryScope === "user" ||
+          (await requireWorkspace(db, workspaceId)).kind === "personal")
+        ? input.authorization
+          ? await fileOwnerContextForAccess({ db }, input.authorization, "sessions:control")
+          : await fileOwnerContextForAgent({ db }, grant, "sessions:control")
+        : undefined,
     );
     await validateGitHubRepositorySelection(db, workspaceId, [
       ...existingSession.resources,
@@ -3634,7 +3706,7 @@ export async function acceptSessionUserMessageWithOutcome(
       ...(input.connectionAuthorities ? { authoritySelections: input.connectionAuthorities } : {}),
     });
     const captureSelectedHostAuthority = prepareSelectedHostTurnAuthority(
-      runtimeSettings,
+      settingsWithSessionMcpServerMetadata(runtimeSettings, existingSession.mcpServers),
       existingSession.tools,
       grant,
       workspaceId,
@@ -4215,3 +4287,28 @@ function hasOwnProperty(value: unknown, key: string): boolean {
     value && typeof value === "object" && Object.prototype.hasOwnProperty.call(value, key),
   );
 }
+
+/** Keep original-file ownership scoped across admission, history hydration and setup. */
+export async function createSessionForRequestWithOutcome(
+  ...args: Parameters<typeof createSessionForRequestInFileScope>
+): Promise<CreateSessionRequestOutcome> {
+  const [deps, grant, , , authorization] = args;
+  const actor = authorization
+    ? await fileOwnerContextForAccess(deps, authorization, "sessions:create")
+    : grant.principalKind === "agent_attempt"
+      ? await fileOwnerContextForAgent(deps, grant, "sessions:create")
+      : { subjectId: grant.subjectId, privateFileOwnerSubjectId: null };
+  return withSessionRlsActorContext(actor, () => createSessionForRequestInFileScope(...args));
+}
+
+export async function acceptSessionUserMessageWithOutcome(
+  ...args: Parameters<typeof acceptSessionUserMessageInFileScope>
+): ReturnType<typeof acceptSessionUserMessageInFileScope> {
+  const [deps, grant, , , input] = args;
+  const actor = input.authorization
+    ? await fileOwnerContextForAccess(deps, input.authorization, "sessions:control")
+    : grant.principalKind === "agent_attempt"
+      ? await fileOwnerContextForAgent(deps, grant, "sessions:control")
+      : { subjectId: grant.subjectId, privateFileOwnerSubjectId: null };
+  return withSessionRlsActorContext(actor, () => acceptSessionUserMessageInFileScope(...args));
+}

package/src/domain/skills.ts

@@ -77,6 +77,14 @@ export async function approveSkill(db: Database, input: SkillRevisionInput) {
     { ...request, operation: "approve" },
   );
 }
+export async function rejectSkill(db: Database, input: SkillRevisionInput) {
+  const { accountId, workspaceId, actor, ...request } = input;
+  return applySkillLifecycle(
+    db,
+    { accountId, workspaceId, actor },
+    { ...request, operation: "reject" },
+  );
+}
 export async function restoreSkill(db: Database, input: SkillRevisionInput) {
   const { accountId, workspaceId, actor, ...request } = input;
   return applySkillLifecycle(

package/src/index.ts

@@ -1,4 +1,6 @@
 export * from "./domain/skills";
+export * from "./domain/knowledge";
+export * from "./domain/knowledge-search";
 // @opengeni/core — the framework-agnostic OpenGeni core.
 //
 // WHAT THIS PACKAGE IS: the OpenGeni domain, access, and billing layers carved
@@ -63,6 +65,7 @@ export * from "./sandbox/runtime-settings";
 export * from "./access";
 export * from "./application/external-workspace-members";
 export * from "./application/external-identity-lifecycle";
+export * from "./application/host-mcp-resolvers";
 export * from "./application/external-continuation";
 export * from "./application/session-mcp-credential-rotation";
 export * from "./application/external-link-work-admission";
@@ -102,10 +105,6 @@ export * from "./domain/governed-learning-slack-publication";
 export * from "./domain/slack-publication-secret-safety";
 export * from "./domain/company-profile-durable-learning-adapter";
 export * from "./domain/company-profile-agent-admin";
-export * from "./domain/company-brain-governed-writes";
-export * from "./domain/governed-learning-evaluator";
-export * from "./domain/governed-learning-activation";
-export * from "./domain/remember";
 export * from "./domain/slack-bot";
 export * from "./domain/conversation-integrations";
 export * from "./domain/fiken";
@@ -126,3 +125,9 @@ export * from "./editable-artifact-live";
 // Transport-neutral editable-artifact domain service, ports, and contracts.
 export * from "./editable-artifacts";
 export { withSiteSessionOrigin } from "./site-session-origin";
+
+export { fileOwnerContextForAccess, fileOwnerContextForAgent } from "./domain/file-owner";
+
+export { prepareKnowledgeFile } from "./domain/knowledge-files";
+
+export { retainKnowledgeMessage } from "./domain/knowledge-messages";

package/src/remote-mcp-credentials.ts

@@ -1,6 +1,14 @@
 import type { Settings } from "@opengeni/config";
+import { environmentsEncryptionKeyBytes } from "@opengeni/config";
+import {
+  resolveHostMcpResolverRoute,
+  hostMcpResolverRouteIsCurrent,
+  type Database,
+  type HostMcpResolverRoute,
+} from "@opengeni/db";
 import {
   McpConnectionResourceScope,
+  hostMcpCredentialUseGuard,
   type ConnectionCredentialsPort,
   type McpCredentialsRequest,
   type McpCredentialResolution,
@@ -144,11 +152,18 @@ export function createRemoteMcpCredentialsPort(
     "hostMcpCredentialResolversJson" | "environment" | "integrationsAllowPrivateNetworkTargets"
   >,
   transport: typeof pinnedFetch = pinnedFetch,
+  routes?: {
+    resolve: (input: { accountId: string; workspaceId: string }) => Promise<HostMcpResolverRoute>;
+    isCurrent: (
+      input: { accountId: string; workspaceId: string },
+      route: HostMcpResolverRoute,
+    ) => Promise<boolean>;
+  },
 ): ConnectionCredentialsPort {
-  if (!settings.hostMcpCredentialResolversJson) return {};
+  if (!settings.hostMcpCredentialResolversJson && !routes) return {};
   let entries: z.infer<typeof configuration>;
   try {
-    entries = configuration.parse(JSON.parse(settings.hostMcpCredentialResolversJson));
+    entries = configuration.parse(JSON.parse(settings.hostMcpCredentialResolversJson || "[]"));
     for (const entry of entries) validateHttpUrl(entry.url);
     if (new Set(entries.map((entry) => entry.accountId)).size !== entries.length) throw new Error();
   } catch {
@@ -188,15 +203,39 @@ export function createRemoteMcpCredentialsPort(
         : {}),
       reason,
     });
-    const config = byAccount.get(request.accountId);
+    let route: HostMcpResolverRoute = { mode: "legacy" };
+    try {
+      if (routes) route = await routes.resolve(request);
+    } catch {
+      return unavailable("refresh_failed");
+    }
+    if (route.mode === "denied") return unavailable("unsupported_auth");
+    const config = route.mode === "namespace" ? route : byAccount.get(request.accountId);
     if (!config || request.connectionRef.authoritySource !== "host")
       return unavailable("unsupported_auth");
+    const current = async () => {
+      try {
+        return routes ? await routes.isCurrent(request, route) : true;
+      } catch {
+        return false;
+      }
+    };
+    const finish = async (value: RemoteResolution): Promise<RemoteResolution> => {
+      if (!(await current())) return unavailable("refresh_failed");
+      const result = structuredClone(value);
+      if (result.status === "ok" && routes) result[hostMcpCredentialUseGuard] = current;
+      return result;
+    };
     // Snapshot before any asynchronous operation; never retain mutable caller
     // objects as the authority for a delayed response.
     if (new TextEncoder().encode(serialized).byteLength > 65_536)
       return unavailable("refresh_failed");
-    const pending = active.get(serialized);
-    if (pending) return structuredClone(await pending);
+    const activeKey = JSON.stringify([
+      route.mode === "namespace" ? [route.id, route.generation] : "legacy",
+      serialized,
+    ]);
+    const pending = active.get(activeKey);
+    if (pending) return finish(await pending);
     if (physicalRequests >= 128) return unavailable("refresh_failed");
     const run = async (): Promise<RemoteResolution> => {
       const requestId = crypto.randomUUID();
@@ -213,6 +252,7 @@ export function createRemoteMcpCredentialsPort(
         return await Promise.race([
           deadline,
           (async () => {
+            if (!(await current())) return unavailable("refresh_failed");
             const response = await transport(
               config.url,
               {
@@ -270,11 +310,11 @@ export function createRemoteMcpCredentialsPort(
       }
     };
     const task = run();
-    active.set(serialized, task);
+    active.set(activeKey, task);
     try {
-      return structuredClone(await task);
+      return finish(await task);
     } finally {
-      if (active.get(serialized) === task) active.delete(serialized);
+      if (active.get(activeKey) === task) active.delete(activeKey);
     }
   };
   return {
@@ -291,3 +331,31 @@ export function createRemoteMcpCredentialsPort(
     },
   };
 }
+
+/** Native standalone transport; the database remains authoritative on every
+ * resolution/use. Embedded in-process ports retain their existing precedence. */
+export function createNativeRemoteMcpCredentialsPort(
+  settings: Settings,
+  db: Database,
+  transport: typeof pinnedFetch = pinnedFetch,
+): ConnectionCredentialsPort {
+  return createRemoteMcpCredentialsPort(settings, transport, {
+    resolve: (request) =>
+      resolveHostMcpResolverRoute(db, request, environmentsEncryptionKeyBytes(settings)),
+    isCurrent: (request, route) => hostMcpResolverRouteIsCurrent(db, request, route),
+  });
+}
+
+/** Parses only server configuration; never return parser errors containing secrets. */
+export function hasLegacyHostMcpResolver(
+  settings: Pick<Settings, "hostMcpCredentialResolversJson">,
+  accountId: string,
+): boolean {
+  try {
+    return configuration
+      .parse(JSON.parse(settings.hostMcpCredentialResolversJson || "[]"))
+      .some((entry) => entry.accountId === accountId);
+  } catch {
+    throw new Error("Invalid host MCP credential resolver configuration");
+  }
+}

package/dist/domain/company-brain-governed-writes.d.ts

@@ -1,79 +0,0 @@
-import { type CompanyBrainGovernedWriteReceipt as CompanyBrainGovernedWriteReceiptType, type CompanyBrainLearningPolicyRouteReceipt as CompanyBrainLearningPolicyRouteReceiptType, type GovernedLearningActivationDestination, type GovernedLearningActivationReceipt } from "@opengeni/contracts";
-import { type Database, activateGovernedLearningDecision, evaluateGovernedLearningProposal, getOrCreateWorkspaceLearningPolicySnapshot, writeCompanyBrainGovernedProposal } from "@opengeni/db";
-import { type GovernedLearningSlackPublicationResult } from "./governed-learning-slack-publication.js";
-export type CompanyBrainGovernedWriteInput = {
-    attempt: unknown;
-    request: unknown;
-};
-export type CompanyBrainGovernedWriteRouterOptions = {
-    db: Database;
-    authority?: typeof writeCompanyBrainGovernedProposal;
-    learningPolicySnapshot?: typeof getOrCreateWorkspaceLearningPolicySnapshot;
-    /** Governed-learning evaluator (migration 0268). Defaults to the DB capability. */
-    evaluate?: typeof evaluateGovernedLearningProposal;
-    /** Governed-learning activation controller (migration 0269). Defaults to the DB capability. */
-    activate?: typeof activateGovernedLearningDecision;
-    /**
-     * Destinations the router may activate automatically from a final eligible
-     * decision. Defaults to Skills and instruction policy. Both still pass
-     * through the evaluator and destination-owned activation lifecycle.
-     */
-    automaticDestinations?: ReadonlyArray<GovernedLearningActivationDestination>;
-    /**
-     * Optional post-activation notification sink (Slack publication outbox).
-     * Notification is never authority: failures are swallowed after the
-     * activation receipt is durable and never change the route receipt.
-     */
-    notifyActivation?: (input: {
-        db: Database;
-        receipt: GovernedLearningActivationReceipt;
-        sessionId: string;
-        attemptId: string;
-    }) => Promise<GovernedLearningSlackPublicationResult>;
-};
-export declare const DEFAULT_AUTOMATIC_LEARNING_DESTINATIONS: ReadonlyArray<GovernedLearningActivationDestination>;
-/**
- * Start a non-authoritative post-activation notification without making the
- * durable activation receipt wait for its settlement. The callback is invoked
- * synchronously so immediate enqueue work begins before the router returns;
- * both synchronous throws and later promise rejections are contained.
- *
- * Exact retries intentionally dispatch again: the publication sink owns an
- * activation-receipt idempotency key, while the activation receipt remains the
- * caller-facing source of truth even if notification delivery stalls forever.
- */
-export declare function dispatchBestEffortGovernedLearningNotification(notify: () => Promise<unknown>): void;
-/**
- * Transport-neutral facade for explicit governed Company Brain proposals.
- * It intentionally exposes no generic remember call, selector, activation,
- * rollback token, or personal/organization destination.
- */
-export declare function createCompanyBrainGovernedWriteRouter(options: CompanyBrainGovernedWriteRouterOptions): {
-    write: (input: CompanyBrainGovernedWriteInput) => Promise<CompanyBrainGovernedWriteReceiptType>;
-};
-/**
- * Deterministic UUIDv5-shaped operation id derived from the caller's proposal
- * operation id, so an exact retry of the same write converges on the same
- * evaluator/activation receipts instead of conflicting.
- */
-export declare function derivedGovernedLearningOperationId(operationId: string, stage: "evaluation" | "activation"): string;
-/**
- * Resolve one derived Company Brain write from the immutable policy snapshot
- * frozen for the exact accepted attempt. The evidence identity is the policy
- * source identity; callers cannot select another override key to widen the
- * decision.
- *
- * After the proposal commits, a Ways-of-working proposal (instruction policy or
- * preference, i.e. one that materialized a `knowledge_change_proposals` row) is
- * evaluated by the governed-learning evaluator against the same accepted
- * snapshot. `suggest` records the content-free decision receipt only. Under
- * `automatic`, a final `automaticEligible` receipt is handed to the activation
- * controller, which revalidates current authority and applies the change only
- * through the destination-owned lifecycle. Eligible Skills and instruction
- * policies may activate automatically. Evaluation or activation failure
- * never rolls back the durable proposal; it is reported as a bounded
- * `learningFailure` and the proposal remains for human review.
- */
-export declare function createCompanyBrainLearningPolicyRouter(options: CompanyBrainGovernedWriteRouterOptions): {
-    write: (input: CompanyBrainGovernedWriteInput) => Promise<CompanyBrainLearningPolicyRouteReceiptType>;
-};

package/dist/domain/governed-learning-activation.d.ts

@@ -1,16 +0,0 @@
-import { type GovernedLearningActivationReceipt, type GovernedLearningActivationUndoReceipt } from "@opengeni/contracts";
-import { activateGovernedLearningDecision, undoGovernedLearningActivation, type Database } from "@opengeni/db";
-export declare function createGovernedLearningActivationController(options: {
-    db: Database;
-    activate?: typeof activateGovernedLearningDecision;
-    undo?: typeof undoGovernedLearningActivation;
-}): {
-    activate(input: {
-        caller: unknown;
-        request: unknown;
-    }): Promise<GovernedLearningActivationReceipt>;
-    undo(input: {
-        caller: unknown;
-        request: unknown;
-    }): Promise<GovernedLearningActivationUndoReceipt>;
-};

package/dist/domain/governed-learning-evaluator.d.ts

@@ -1,6 +0,0 @@
-import { type GovernedLearningDecision as GovernedLearningDecisionType, type GovernedLearningDecisionFacts as GovernedLearningDecisionFactsType } from "@opengeni/contracts";
-/**
- * Pure, closed evaluator mirrored by the 0268 database authority. It never
- * receives source content and cannot activate a destination authority.
- */
-export declare function deriveGovernedLearningDecision(input: GovernedLearningDecisionFactsType): GovernedLearningDecisionType;

package/dist/domain/remember.d.ts

@@ -1,72 +0,0 @@
-import { type RememberLane, type GovernedLearningActivationReceipt, type RememberConfirmReceipt as RememberConfirmReceiptType, type RememberReceipt as RememberReceiptType } from "@opengeni/contracts";
-import { type Database, activateHumanConfirmedLearningDecision, archiveTaskNote, confirmRememberKnowledgeClaim, createTaskNote, getWorkspaceInstructionPolicyBaseline, getWorkspaceKnowledgeChangeProposalSummary, getWorkspaceKnowledgeClaimInitiatingHuman, materializeConfirmedRememberKnowledgeMemory, rebaselineWorkspaceInstructionPolicyKnowledgeProposal } from "@opengeni/db";
-import { createCompanyBrainLearningPolicyRouter } from "./company-brain-governed-writes.js";
-export declare class RememberError extends Error {
-    readonly code: "proposal_unavailable" | "proposal_not_confirmable" | "human_confirmation_unavailable" | "preference_retired" | "baseline_stale";
-    readonly name = "RememberError";
-    constructor(code: "proposal_unavailable" | "proposal_not_confirmable" | "human_confirmation_unavailable" | "preference_retired" | "baseline_stale", message: string);
-}
-export type RememberRouterOptions = {
-    db: Database;
-    learningRouter?: Pick<ReturnType<typeof createCompanyBrainLearningPolicyRouter>, "write">;
-    createNote?: typeof createTaskNote;
-    archiveNote?: typeof archiveTaskNote;
-    rebaselineProposal?: typeof rebaselineWorkspaceInstructionPolicyKnowledgeProposal;
-    activateHumanConfirmed?: typeof activateHumanConfirmedLearningDecision;
-    confirmKnowledgeClaim?: typeof confirmRememberKnowledgeClaim;
-    materializeKnowledgeMemory?: typeof materializeConfirmedRememberKnowledgeMemory;
-    proposalSummary?: typeof getWorkspaceKnowledgeChangeProposalSummary;
-    claimInitiatingHuman?: typeof getWorkspaceKnowledgeClaimInitiatingHuman;
-    instructionPolicyBaseline?: typeof getWorkspaceInstructionPolicyBaseline;
-    notifyActivation?: (input: {
-        db: Database;
-        receipt: GovernedLearningActivationReceipt;
-        sessionId: string;
-        attemptId: string;
-    }) => Promise<unknown>;
-};
-/** Deterministic UUID-shaped id derived from the caller's remember operation id. */
-export declare function derivedRememberOperationId(operationId: string, stage: "note" | "note-archive" | "promotion" | "evaluation" | "activation" | "rebaseline"): string;
-/**
- * What saving this costs, shown on the confirmation card so a human can judge
- * the length before agreeing. A mandatory rule is composed into the prompt of
- * every session it applies to; a preference contributes only its short
- * descriptor to that prompt and keeps its content behind on-demand retrieval;
- * knowledge is retrieval evidence and never joins the always-composed prefix.
- *
- * `HumanInputForm` renders a single question's `label` as the card heading and
- * its `prompt` as the sub-text, so this stays a title with a parenthetical
- * rather than a sentence: the question the human answers has to keep reading as
- * the heading of the card.
- *
- * This deliberately lives on `label` rather than `helpText`: migrations 0272 /
- * 0274 / 0284 / 0293 / 0316 byte-verify the reconstructed `prompt`, `helpText`,
- * and `options` against the exact Task-note text before authorizing an
- * activation, and `label` is the one field of the canonical question those
- * capabilities do not constrain.
- */
-export declare function rememberConfirmationLabel(input: {
-    lane: RememberLane;
-    contentChars: number;
-    /** Role-scoped rules compose only for sessions bound to that role. */
-    policyScope?: "global" | "role" | undefined;
-}): string;
-/**
- * Explicit user-directed remember. Content becomes an exact task note (the
- * evidence), the note is promoted through the frozen learning policy router,
- * and the result is either an immediate activation (automatic policy), a
- * proposal for the human Knowledge review lifecycle, or a durable proposal that
- * still needs one bound human confirmation through `request_human_input`.
- * A confirmed Knowledge claim is then materialized as a keyword-searchable
- * Memory record from its exact approved Task-note text.
- */
-export declare function createRememberRouter(options: RememberRouterOptions): {
-    remember: (input: {
-        attempt: unknown;
-        request: unknown;
-    }) => Promise<RememberReceiptType>;
-    confirm: (input: {
-        attempt: unknown;
-        request: unknown;
-    }) => Promise<RememberConfirmReceiptType>;
-};