@opengeni/core 0.17.1 → 0.18.0

package/dist/domain/memory-slack-publication.d.ts

@@ -0,0 +1,107 @@
+import { type KnowledgeMemoryKind, type KnowledgeMemoryStatus } from "@opengeni/contracts";
+export declare const MEMORY_SLACK_PROJECTION_VERSION = 1;
+export declare const MEMORY_SLACK_SUMMARY_MAX_UTF8_BYTES = 512;
+export declare const MEMORY_SLACK_NAMESPACE_MAX_UTF8_BYTES = 128;
+export declare const MEMORY_SLACK_LABEL_MAX_UTF8_BYTES = 64;
+export declare const MEMORY_SLACK_LABEL_MAX_COUNT = 8;
+export declare const MEMORY_SLACK_OWNER_MAX_UTF8_BYTES = 96;
+export declare const MEMORY_SLACK_PROJECTION_MAX_UTF8_BYTES = 4096;
+export type MemorySlackImportance = "major" | "normal" | "minor";
+export type MemorySlackRequestedMode = "auto" | "review" | "never";
+export type MemorySlackDeliveryMode = Exclude<MemorySlackRequestedMode, "never">;
+export type MemorySlackChangeKind = "created" | "corrected" | "superseded";
+export type MemorySlackOrigin = "native" | "slack_derived";
+export type MemorySlackAudience = "workspace" | "restricted";
+export type MemorySlackPublicationPolicy = {
+    enabled: boolean;
+    autoImportances: readonly MemorySlackImportance[];
+    reviewImportances: readonly MemorySlackImportance[];
+};
+/**
+ * Nothing publishes without an explicit workspace-admin enablement. When
+ * enabled without tuning, major changes may publish automatically, normal
+ * changes require review, and minor changes stay quiet.
+ */
+export declare const DEFAULT_MEMORY_SLACK_PUBLICATION_POLICY: {
+    readonly enabled: false;
+    readonly autoImportances: readonly ["major"];
+    readonly reviewImportances: readonly ["normal"];
+};
+export type MemorySlackPublicationInput = {
+    context: {
+        accountId: string;
+        workspaceId: string;
+        now: string;
+    };
+    policy?: MemorySlackPublicationPolicy | undefined;
+    memory: {
+        sourceType: "workspace_memory";
+        accountId: string;
+        workspaceId: string;
+        id: string;
+        version: number;
+        status: KnowledgeMemoryStatus;
+        kind: KnowledgeMemoryKind;
+        scopeType: "workspace" | "user" | "role" | "session" | "ephemeral" | "legacy";
+        namespace: string;
+        labels: readonly string[];
+        validFrom: string;
+        validUntil: string | null;
+        supersedesId: string | null;
+        supersededById: string | null;
+    };
+    change: {
+        kind: MemorySlackChangeKind;
+        relatedMemoryId: string | null;
+        occurredAt: string;
+        origin: MemorySlackOrigin;
+        ownerLabel?: string | null | undefined;
+    };
+    distribution: {
+        importance: MemorySlackImportance;
+        audience: MemorySlackAudience;
+        slackMode: MemorySlackRequestedMode;
+        shareSummary: string;
+    };
+};
+export type MemorySlackPublicationDenialReason = "disabled" | "invalid_input" | "unsupported_source" | "tenant_mismatch" | "not_decision" | "status_ineligible" | "restricted_scope" | "restricted_audience" | "not_yet_valid" | "expired" | "slack_origin_loop" | "mode_never" | "below_noise_policy" | "missing_summary" | "invalid_change_lineage";
+export type MemorySlackPublicationProjection = {
+    version: typeof MEMORY_SLACK_PROJECTION_VERSION;
+    workspaceId: string;
+    memoryId: string;
+    memoryVersion: number;
+    changeKind: MemorySlackChangeKind;
+    relatedMemoryId: string | null;
+    occurredAt: string;
+    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;
+        memoryId: string;
+    };
+};
+export type MemorySlackPublicationDecision = {
+    eligible: false;
+    reason: MemorySlackPublicationDenialReason;
+} | {
+    eligible: true;
+    deliveryMode: MemorySlackDeliveryMode;
+    idempotencyKey: string;
+    projection: MemorySlackPublicationProjection;
+};
+/**
+ * Produce the only data shape a later delivery slice may persist or
+ * render. This is a deterministic policy/security boundary, not a persistence
+ * hook: callers must durably bind the returned projection and key in a later
+ * transaction/outbox slice.
+ */
+export declare function evaluateMemorySlackPublication(input: MemorySlackPublicationInput): MemorySlackPublicationDecision;

package/dist/index.d.ts

@@ -18,6 +18,7 @@ export * from "./domain/session-tool-policy";
 export * from "./domain/scheduled-tasks";
 export * from "./domain/sessions";
 export * from "./domain/insights";
+export * from "./domain/memory-slack-publication";
 export * from "./domain/slack-bot";
 export * from "./domain/workspace-members";
 export * from "./application/new-session-drafts";

package/dist/index.js

@@ -2356,6 +2356,19 @@ async function requireCatalogItem(db, workspaceId, settings, capabilityId) {
   return item;
 }
 function packCatalogItem(pack, source) {
+  const customMetadata = { ...pack.metadata };
+  for (const key of [
+    "packId",
+    "version",
+    "connectors",
+    "knowledge",
+    "scheduledTaskTemplates",
+    "sandboxImage",
+    "sandboxProviderImages",
+    "skills"
+  ]) {
+    delete customMetadata[key];
+  }
   return CapabilityCatalogItem.parse({
     id: `pack:${pack.id}`,
     kind: "pack",
@@ -2370,6 +2383,7 @@ function packCatalogItem(pack, source) {
       notes: "Enables role-scoped tools, connectors, knowledge, and scheduled-task templates."
     },
     metadata: {
+      ...customMetadata,
       packId: pack.id,
       version: pack.version,
       connectors: pack.connectors,
@@ -2377,8 +2391,8 @@ function packCatalogItem(pack, source) {
       scheduledTaskTemplates: pack.scheduledTaskTemplates,
       // Runtime composition surface only: skill names, never file content.
       ...pack.sandboxImage ? { sandboxImage: pack.sandboxImage } : {},
-      ...pack.skills.length > 0 ? { skills: pack.skills.map((skill) => skill.name) } : {},
-      ...pack.metadata
+      ...pack.sandboxProviderImages ? { sandboxProviderImages: pack.sandboxProviderImages } : {},
+      ...pack.skills.length > 0 ? { skills: pack.skills.map((skill) => skill.name) } : {}
     }
   });
 }
@@ -5965,6 +5979,236 @@ async function getWorkspaceInsights(db, settings, input) {
   return { snapshot };
 }
 
+// src/domain/memory-slack-publication.ts
+import { createHash } from "crypto";
+import {
+  redactSensitiveText,
+  stableJson as stableJson3
+} from "@opengeni/contracts";
+var UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var SELECTOR_SEGMENT_PATTERN = /^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/;
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+var MEMORY_SLACK_PROJECTION_VERSION = 1;
+var MEMORY_SLACK_SUMMARY_MAX_UTF8_BYTES = 512;
+var MEMORY_SLACK_NAMESPACE_MAX_UTF8_BYTES = 128;
+var MEMORY_SLACK_LABEL_MAX_UTF8_BYTES = 64;
+var MEMORY_SLACK_LABEL_MAX_COUNT = 8;
+var MEMORY_SLACK_OWNER_MAX_UTF8_BYTES = 96;
+var MEMORY_SLACK_PROJECTION_MAX_UTF8_BYTES = 4096;
+var DEFAULT_MEMORY_SLACK_PUBLICATION_POLICY = {
+  enabled: false,
+  autoImportances: ["major"],
+  reviewImportances: ["normal"]
+};
+var IMPORTANCES = /* @__PURE__ */ new Set(["major", "normal", "minor"]);
+var REQUESTED_MODES = /* @__PURE__ */ new Set(["auto", "review", "never"]);
+var CHANGE_KINDS = /* @__PURE__ */ new Set(["created", "corrected", "superseded"]);
+var ORIGINS = /* @__PURE__ */ new Set(["native", "slack_derived"]);
+var AUDIENCES = /* @__PURE__ */ new Set(["workspace", "restricted"]);
+var SCOPE_TYPES = /* @__PURE__ */ new Set([
+  "workspace",
+  "user",
+  "role",
+  "session",
+  "ephemeral",
+  "legacy"
+]);
+var MEMORY_STATUSES = /* @__PURE__ */ new Set([
+  "proposed",
+  "approved",
+  "rejected",
+  "active",
+  "superseded",
+  "archived"
+]);
+var MEMORY_KINDS = /* @__PURE__ */ new Set([
+  "semantic",
+  "episodic",
+  "procedural",
+  "decision",
+  "preference"
+]);
+var VISIBLE_STATUSES = /* @__PURE__ */ new Set(["active", "approved"]);
+function evaluateMemorySlackPublication(input) {
+  const policy = input.policy ?? DEFAULT_MEMORY_SLACK_PUBLICATION_POLICY;
+  if (!validPolicy(policy)) return denied("invalid_input");
+  if (!policy.enabled) return denied("disabled");
+  if (input.memory.sourceType !== "workspace_memory") return denied("unsupported_source");
+  if (!validIdentity(input)) return denied("invalid_input");
+  if (input.memory.accountId !== input.context.accountId || input.memory.workspaceId !== input.context.workspaceId) {
+    return denied("tenant_mismatch");
+  }
+  if (input.memory.kind !== "decision") return denied("not_decision");
+  if (input.memory.scopeType !== "workspace") return denied("restricted_scope");
+  if (input.distribution.audience !== "workspace") return denied("restricted_audience");
+  if (input.change.origin === "slack_derived") return denied("slack_origin_loop");
+  if (input.distribution.slackMode === "never") return denied("mode_never");
+  const timeDecision = evaluateValidity(input);
+  if (timeDecision) return denied(timeDecision);
+  if (!statusEligibleForChange(input)) return denied("status_ineligible");
+  if (!validChangeLineage(input)) return denied("invalid_change_lineage");
+  const deliveryMode = effectiveDeliveryMode(policy, input.distribution);
+  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);
+  const namespace = normalizeNamespace(input.memory.namespace);
+  const labels = normalizeLabels(input.memory.labels);
+  if (!namespace || !labels) return denied("invalid_input");
+  const owner = boundedOptionalText(input.change.ownerLabel, MEMORY_SLACK_OWNER_MAX_UTF8_BYTES);
+  const projection = {
+    version: MEMORY_SLACK_PROJECTION_VERSION,
+    workspaceId: input.context.workspaceId,
+    memoryId: input.memory.id,
+    memoryVersion: input.memory.version,
+    changeKind: input.change.kind,
+    relatedMemoryId: input.change.relatedMemoryId,
+    occurredAt: new Date(input.change.occurredAt).toISOString(),
+    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,
+      memoryId: input.memory.id
+    }
+  };
+  if (utf8Bytes(stableJson3(projection)) > MEMORY_SLACK_PROJECTION_MAX_UTF8_BYTES) {
+    return denied("invalid_input");
+  }
+  const digest = createHash("sha256").update(stableJson3(projection), "utf8").digest("hex");
+  return {
+    eligible: true,
+    deliveryMode,
+    idempotencyKey: `memory-slack:v${MEMORY_SLACK_PROJECTION_VERSION}:${digest}`,
+    projection
+  };
+}
+function validPolicy(policy) {
+  return typeof policy.enabled === "boolean" && Array.isArray(policy.autoImportances) && Array.isArray(policy.reviewImportances) && policy.autoImportances.every((importance) => IMPORTANCES.has(importance)) && policy.reviewImportances.every((importance) => IMPORTANCES.has(importance));
+}
+function validIdentity(input) {
+  const uuids = [
+    input.context.accountId,
+    input.context.workspaceId,
+    input.memory.accountId,
+    input.memory.workspaceId,
+    input.memory.id,
+    input.memory.supersedesId,
+    input.memory.supersededById,
+    input.change.relatedMemoryId
+  ].filter((value) => value !== null);
+  return uuids.every((value) => UUID_PATTERN.test(value)) && Number.isSafeInteger(input.memory.version) && input.memory.version > 0 && typeof input.memory.namespace === "string" && Array.isArray(input.memory.labels) && input.memory.labels.every((label) => typeof label === "string") && (input.change.ownerLabel === void 0 || input.change.ownerLabel === null || typeof input.change.ownerLabel === "string") && typeof input.distribution.shareSummary === "string" && IMPORTANCES.has(input.distribution.importance) && REQUESTED_MODES.has(input.distribution.slackMode) && CHANGE_KINDS.has(input.change.kind) && ORIGINS.has(input.change.origin) && AUDIENCES.has(input.distribution.audience) && SCOPE_TYPES.has(input.memory.scopeType) && MEMORY_STATUSES.has(input.memory.status) && MEMORY_KINDS.has(input.memory.kind);
+}
+function evaluateValidity(input) {
+  const now = Date.parse(input.context.now);
+  const occurredAt = Date.parse(input.change.occurredAt);
+  const validFrom = Date.parse(input.memory.validFrom);
+  const validUntil = input.memory.validUntil === null ? null : Date.parse(input.memory.validUntil);
+  if (!Number.isFinite(now) || !Number.isFinite(occurredAt) || !Number.isFinite(validFrom) || validUntil !== null && !Number.isFinite(validUntil) || validUntil !== null && validUntil <= validFrom) {
+    return "invalid_input";
+  }
+  if (now < validFrom) return "not_yet_valid";
+  if (validUntil !== null && now >= validUntil) return "expired";
+  return null;
+}
+function validChangeLineage(input) {
+  if (input.memory.supersedesId === input.memory.id || input.memory.supersededById === input.memory.id || input.change.relatedMemoryId === input.memory.id) {
+    return false;
+  }
+  switch (input.change.kind) {
+    case "created":
+      return input.change.relatedMemoryId === null && input.memory.supersedesId === null && input.memory.supersededById === null;
+    case "corrected":
+      return input.change.relatedMemoryId !== null && input.change.relatedMemoryId !== input.memory.id && input.memory.supersedesId === input.change.relatedMemoryId && input.memory.supersededById === null;
+    case "superseded":
+      return input.change.relatedMemoryId !== null && input.change.relatedMemoryId !== input.memory.id && input.memory.supersededById === input.change.relatedMemoryId;
+  }
+}
+function statusEligibleForChange(input) {
+  return input.change.kind === "superseded" ? input.memory.status === "superseded" : VISIBLE_STATUSES.has(input.memory.status);
+}
+function effectiveDeliveryMode(policy, distribution) {
+  const auto = new Set(policy.autoImportances);
+  const review = new Set(policy.reviewImportances);
+  if (distribution.slackMode === "review") {
+    return auto.has(distribution.importance) || review.has(distribution.importance) ? "review" : null;
+  }
+  if (auto.has(distribution.importance)) return "auto";
+  if (review.has(distribution.importance)) return "review";
+  return null;
+}
+function normalizeNamespace(value) {
+  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("/");
+}
+function normalizeLabels(values) {
+  if (!Array.isArray(values)) return null;
+  const labels = /* @__PURE__ */ new Set();
+  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) {
+      return null;
+    }
+    labels.add(label);
+  }
+  const sorted = [...labels].sort();
+  return {
+    values: sorted.slice(0, MEMORY_SLACK_LABEL_MAX_COUNT),
+    truncated: sorted.length > MEMORY_SLACK_LABEL_MAX_COUNT
+  };
+}
+function boundedOptionalText(value, maxBytes) {
+  const collapsed = collapseText(value ?? "");
+  if (!collapsed) return { value: null, redacted: false, truncated: false };
+  const redacted = redactSensitiveText(collapsed);
+  const bounded = truncateUtf8(redacted, maxBytes);
+  return {
+    value: bounded.value || null,
+    redacted: redacted !== collapsed,
+    truncated: bounded.truncated
+  };
+}
+function collapseText(value) {
+  return value.replace(/[\u0000-\u001F\u007F-\u009F]/g, " ").replace(/\s+/g, " ").trim();
+}
+function truncateUtf8(value, maxBytes) {
+  const bytes = encoder.encode(value);
+  if (bytes.byteLength <= maxBytes) return { value, truncated: false };
+  const marker = "\u2026";
+  const markerBytes = encoder.encode(marker);
+  let end = Math.max(0, maxBytes - markerBytes.byteLength);
+  while (end > 0 && (bytes[end] & 192) === 128) end -= 1;
+  return {
+    value: `${decoder.decode(bytes.subarray(0, end)).trimEnd()}${marker}`,
+    truncated: true
+  };
+}
+function utf8Bytes(value) {
+  return encoder.encode(value).byteLength;
+}
+function denied(reason) {
+  return { eligible: false, reason };
+}
+
 // src/domain/workspace-members.ts
 import { HTTPException as HTTPException12 } from "hono/http-exception";
 var MEMBER_ADMIN_PERMISSIONS = ["workspace:admin", "members:manage"];
@@ -6678,6 +6922,7 @@ async function saveHumanComposerDraft(deps, context, input) {
 export {
   CODEX_COMPACTION_V2_PROVIDER_LOCKED,
   CodexCompactionV2ProviderLockedError,
+  DEFAULT_MEMORY_SLACK_PUBLICATION_POLICY,
   MARKETING_SOCIAL_PACK_ID,
   MAX_CHECKS_PER_RIG,
   MAX_CREDENTIAL_HOOKS_PER_RIG,
@@ -6685,6 +6930,13 @@ export {
   MAX_ENVIRONMENTS_PER_WORKSPACE,
   MAX_RIGS_PER_WORKSPACE,
   MAX_VARIABLES_PER_ENVIRONMENT,
+  MEMORY_SLACK_LABEL_MAX_COUNT,
+  MEMORY_SLACK_LABEL_MAX_UTF8_BYTES,
+  MEMORY_SLACK_NAMESPACE_MAX_UTF8_BYTES,
+  MEMORY_SLACK_OWNER_MAX_UTF8_BYTES,
+  MEMORY_SLACK_PROJECTION_MAX_UTF8_BYTES,
+  MEMORY_SLACK_PROJECTION_VERSION,
+  MEMORY_SLACK_SUMMARY_MAX_UTF8_BYTES,
   SESSION_AUTHORIZATION_DEFAULT_REAUTHORIZE_MS,
   SESSION_WORKFLOW_WAKE_DISPATCHER_PERIOD_MS,
   SESSION_WORKFLOW_WAKE_DISPATCHER_SCHEDULE_ID,
@@ -6734,6 +6986,7 @@ export {
   editHumanQueuePrompt,
   enableCapability,
   enabledCapabilityMcpToolRefs,
+  evaluateMemorySlackPublication,
   executeRunOnSelfhostedMachine,
   filenameForMimeType,
   freezePersonalConnectionDelegations,