@remnic/core 9.14.0 → 9.15.1

package/dist/{chunk-3HYWNJDA.js → chunk-HWFK24UD.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-GDB4J2H3.js";
 import {
   importCapsule
-} from "./chunk-ALSGMEJR.js";
+} from "./chunk-7CPOZH6Y.js";
 import {
   WriteQuarantineStore
 } from "./chunk-PJSK6OJM.js";
@@ -30,18 +30,18 @@ import {
 import {
   planSessionTranscriptMigration
 } from "./chunk-P5FPO2BR.js";
-import {
-  decideDisclosureEscalation
-} from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
 } from "./chunk-CQMEM5CC.js";
 import {
   estimateRecallTokens
 } from "./chunk-U3ZAVRP3.js";
+import {
+  decideDisclosureEscalation
+} from "./chunk-H7XKCNR6.js";
 import {
   namespaceCollectionName
-} from "./chunk-IAHNKI2E.js";
+} from "./chunk-QDNE35FU.js";
 import {
   buildProposedActions,
   buildQualityScore,
@@ -49,7 +49,7 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-HLG7VAZP.js";
+} from "./chunk-BOP256DB.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
 } from "./chunk-ICP53SKG.js";
@@ -58,7 +58,7 @@ import {
 } from "./chunk-6HMYUWXR.js";
 import {
   offlineSyncStorageForSnapshot
-} from "./chunk-SK7AMF2J.js";
+} from "./chunk-DETNBTZS.js";
 import {
   combineNamespaces,
   defaultGitInvoker,
@@ -69,9 +69,10 @@ import {
   resolveGitContext,
   resolveScopePlan,
   resolveScopeProfilePlan,
+  resolveScopedWritableNamespaceValue,
   resolveWritableNamespaceValue,
   sanitizeFragment
-} from "./chunk-MMGGVZ4Q.js";
+} from "./chunk-7VZWZVYG.js";
 import {
   recordMemoryOutcome
 } from "./chunk-EIR5VLIH.js";
@@ -113,13 +114,13 @@ import {
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-7G7DVA2C.js";
+} from "./chunk-BVC242OS.js";
 import {
   parseEntityFile,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   selfDeps
-} from "./chunk-7HZMTXXB.js";
+} from "./chunk-RWSLO24I.js";
 import {
   supersessionKeysForFact
 } from "./chunk-DNHVPZOD.js";
@@ -133,6 +134,10 @@ import {
 import {
   serializeMutations
 } from "./chunk-WL5EBRDH.js";
+import {
+  inferMemoryStatus,
+  toMemoryPathRel
+} from "./chunk-ILGC6JH6.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -143,10 +148,6 @@ import {
 import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
-import {
-  inferMemoryStatus,
-  toMemoryPathRel
-} from "./chunk-ILGC6JH6.js";
 import {
   STRUCTURED_ATTRIBUTE_LIMITS,
   buildAccessWriteRequestFingerprint,
@@ -168,6 +169,14 @@ import {
 import {
   computeContentHash
 } from "./chunk-W5H6ZRPT.js";
+import {
+  assertFleetWideOperationAllowed,
+  assertOperationAllowed,
+  capabilityAllowsOp,
+  enforceNamespaceAllowList,
+  isNamespaceAllowed,
+  tokenCapabilityStore
+} from "./chunk-7AMFUATK.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -180,7 +189,7 @@ import {
 } from "./chunk-JAKIDQB2.js";
 import {
   exportCapsule
-} from "./chunk-5W7CTZ2E.js";
+} from "./chunk-KQAFEZQX.js";
 import {
   evaluateActionConfidence
 } from "./chunk-Z2YFLXHU.js";
@@ -196,6 +205,7 @@ import {
   readOfflineSyncFileContentChunk
 } from "./chunk-E4OCKU67.js";
 import {
+  EngramAccessForbiddenError,
   EngramAccessInputError,
   NamespaceNotWritableError
 } from "./chunk-2Z24E5W2.js";
@@ -4782,6 +4792,333 @@ function formatProcedureStatsText(report) {
   return lines.join("\n") + "\n";
 }
 
+// src/access-boundary.ts
+import { z } from "zod";
+var OPERATION_NAMES = [
+  "memory_get",
+  "memory_search",
+  "memory_store",
+  "coding_decision",
+  "coding_architecture",
+  // codegraph parity tools (issue #1554) -- each maps to one codegraph_*
+  // boundary operation that delegates to the surface handler in
+  // coding/codegraph-surfaces.ts. Names match the external tool suffixes.
+  "codegraph_index",
+  "codegraph_list_projects",
+  "codegraph_delete_project",
+  "codegraph_index_status",
+  "codegraph_search_graph",
+  "codegraph_trace_path",
+  "codegraph_detect_changes",
+  "codegraph_query_graph",
+  "codegraph_get_schema",
+  "codegraph_get_snippet",
+  "codegraph_get_architecture",
+  "codegraph_search_code",
+  "codegraph_manage_adr",
+  "codegraph_ingest_traces",
+  "memory_correct_plan",
+  "memory_correct_apply",
+  "coding_delta",
+  // Remaining MCP/HTTP handlers migrated through the boundary (issue #1525).
+  "recall",
+  "recall_explain",
+  "set_coding_context",
+  "recall_tier_explain",
+  "recall_xray",
+  "namespace_writable",
+  "wearables_status",
+  "wearables_sync",
+  "transcript_day",
+  "transcript_search",
+  "transcript_memories",
+  "action_confidence",
+  "chatgpt_memory_inspector",
+  "day_summary",
+  "capsule_export",
+  "capsule_import",
+  "capsule_list",
+  "memory_governance_run",
+  "procedure_mining_run",
+  "pattern_reinforcement_run",
+  "procedural_stats",
+  "memory_timeline",
+  "suggestion_submit",
+  "entity_get",
+  "review_queue_list",
+  "correction_pending",
+  "observe",
+  "lcm_search",
+  "lcm_compaction_flush",
+  "lcm_compaction_record",
+  "continuity_audit_generate",
+  "continuity_incident_open",
+  "continuity_incident_close",
+  "continuity_incident_list",
+  "continuity_loop_add_or_update",
+  "continuity_loop_review",
+  "identity_anchor_get",
+  "identity_anchor_update",
+  "memory_identity",
+  "work_task",
+  "work_project",
+  "work_board",
+  "shared_context_write_output",
+  "shared_feedback_record",
+  "shared_priorities_append",
+  "relay_mission_append",
+  "relay_mission_read",
+  "shared_context_cross_signals_run",
+  "shared_context_curate_daily",
+  "compounding_weekly_synthesize",
+  "compounding_promote_candidate",
+  "compression_guidelines_optimize",
+  "compression_guidelines_activate",
+  "memory_profile",
+  "memory_entities_list",
+  "memory_questions",
+  "memory_last_recall",
+  "memory_intent_debug",
+  "memory_qmd_debug",
+  "memory_graph_explain",
+  "graph_snapshot",
+  "memory_feedback",
+  "memory_promote",
+  "memory_outcome",
+  "memory_action_apply",
+  "context_checkpoint",
+  "briefing",
+  "review_list",
+  "review_resolve",
+  "contradiction_scan_run",
+  "memory_summarize_hourly",
+  "conversation_index_update",
+  "profiling_report",
+  "graph_edge_decay_run",
+  "live_connectors_run",
+  "peer_list",
+  "peer_get",
+  "peer_set",
+  "peer_delete",
+  "peer_profile_get",
+  "peer_forget",
+  "console_state",
+  "dreams_status",
+  "dreams_run",
+  // HTTP-only routes (no direct MCP tool equivalent).
+  "adapters_status",
+  "offline_sync_snapshot",
+  "offline_sync_snapshot_stream",
+  "offline_sync_files",
+  "offline_sync_file_content",
+  "offline_sync_apply_file_content",
+  "offline_sync_apply",
+  "lcm_status",
+  "memory_list",
+  "recall_timings",
+  "entity_list",
+  "maintenance_status",
+  "quality_status",
+  "trust_zones_status",
+  "trust_zones_records",
+  "review_disposition",
+  "trust_zones_promote",
+  "trust_zones_demo_seed",
+  "citations_observed",
+  "contradiction_detail",
+  "graph_events",
+  // Chat surface — conversational memory inspection/correction (issue #1583).
+  "chat_message",
+  "chat_events"
+];
+function coerceBooleanLike(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lower = value.trim().toLowerCase();
+    if (lower === "true" || lower === "1" || lower === "yes" || lower === "on") return true;
+    if (lower === "false" || lower === "0" || lower === "no" || lower === "off") return false;
+  }
+  throw new EngramAccessInputError(
+    `expected a boolean-like value (true|false|1|0|yes|no|on|off); got ${JSON.stringify(value)}`
+  );
+}
+function coercePositiveInteger(value, label) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || value <= 0 || !Number.isInteger(value)) {
+      throw new EngramAccessInputError(`${label} expects a positive integer; got ${JSON.stringify(value)}`);
+    }
+    return value;
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!/^[+-]?\d+$/.test(trimmed)) {
+      throw new EngramAccessInputError(`${label} expects a positive integer; got ${JSON.stringify(value)}`);
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isSafeInteger(parsed) || parsed <= 0) {
+      throw new EngramAccessInputError(`${label} expects a positive integer; got ${JSON.stringify(value)}`);
+    }
+    return parsed;
+  }
+  throw new EngramAccessInputError(`${label} expects a positive integer; got ${JSON.stringify(value)}`);
+}
+function normalizeOptionalPath(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") {
+    throw new EngramAccessInputError(`expected a path string; got ${JSON.stringify(value)}`);
+  }
+  return expandTildePath(value);
+}
+function formatZodIssues(error) {
+  const parts = [];
+  for (const issue of error.issues) {
+    const hasNumeric = issue.path.some((p) => typeof p === "number");
+    const path9 = hasNumeric ? issue.path.filter((p) => typeof p === "string").join(".") || "(root)" : issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    const options = enumOptionsFromIssue(issue);
+    const suffix = options ? `. Valid: ${options.join(", ")}` : "";
+    parts.push(`${path9}: ${issue.message}${suffix}`);
+  }
+  return parts.length > 0 ? `request validation failed: ${parts.join("; ")}` : "request validation failed";
+}
+function enumOptionsFromIssue(issue) {
+  if (issue.code === z.ZodIssueCode.invalid_enum_value) {
+    const rawOptions = issue.options;
+    if (Array.isArray(rawOptions)) {
+      return rawOptions.map((opt) => String(opt));
+    }
+  }
+  return void 0;
+}
+var registry = /* @__PURE__ */ new Map();
+var humanReadableErrorMap = (issue, ctx) => {
+  if (issue.code === z.ZodIssueCode.invalid_type) {
+    if (issue.received === "undefined") return { message: ctx.defaultError };
+    if (issue.path.some((p) => typeof p === "number")) {
+      const arrField = issue.path.filter((p) => typeof p === "string").join(".");
+      return { message: `${arrField} must be an array of ${issue.expected}s` };
+    }
+    const fieldName = issue.path.length > 0 ? String(issue.path[issue.path.length - 1]) : "value";
+    switch (issue.expected) {
+      case "string":
+        return { message: `${fieldName} must be a string` };
+      case "boolean":
+        return { message: `${fieldName} must be a boolean` };
+      case "number":
+        return { message: `${fieldName} must be a number` };
+      case "array":
+        return { message: `${fieldName} must be an array` };
+      case "object":
+        return { message: `${fieldName} must be an object` };
+      default:
+        return { message: ctx.defaultError };
+    }
+  }
+  return { message: ctx.defaultError };
+};
+function defineOperation(spec) {
+  if (registry.has(spec.name)) {
+    throw new Error(`access-boundary: operation already registered: ${spec.name}`);
+  }
+  const bound = {
+    spec,
+    run: async (rawInput, ctx) => {
+      const parseResult = spec.schema.safeParse(rawInput, { errorMap: humanReadableErrorMap });
+      if (!parseResult.success) {
+        throw new EngramAccessInputError(formatZodIssues(parseResult.error));
+      }
+      if (spec.allowedByOps && spec.allowedByOps.length > 0) {
+        const store = tokenCapabilityStore.getStore();
+        if (!spec.allowedByOps.some((op) => capabilityAllowsOp(store, op))) {
+          throw new EngramAccessForbiddenError(`token is not permitted to call operation: ${spec.name}`);
+        }
+      } else {
+        assertOperationAllowed(tokenCapabilityStore.getStore(), spec.name);
+      }
+      if (spec.fleetWide) {
+        assertFleetWideOperationAllowed(tokenCapabilityStore.getStore());
+      }
+      return spec.handler(parseResult.data, ctx);
+    }
+  };
+  registry.set(spec.name, bound);
+  return bound;
+}
+function getOperation(name) {
+  return registry.get(name);
+}
+function listRegisteredOperations() {
+  return [...registry.keys()];
+}
+function __resetRegistryForTest() {
+  registry.clear();
+}
+
+// src/access-namespace-preflight.ts
+function namespaceWritableRequest(params, authenticatedPrincipal) {
+  const namespace = params.get("namespace") || void 0;
+  return {
+    namespace,
+    sessionKey: params.get("session") || void 0,
+    authenticatedPrincipal,
+    cwd: params.get("cwd") || void 0,
+    projectTag: params.get("projectTag") || void 0
+  };
+}
+function parseNamespacePreflightWriteOp(value) {
+  if (value === void 0 || value === "observe") return "observe";
+  if (value === "memory_store") return "memory_store";
+  throw new EngramAccessInputError(`unsupported namespace preflight operation: ${value}`);
+}
+function assertNamespacePreflightPermitted(caps) {
+  const allowedOps = getOperation("namespace_writable")?.spec.allowedByOps ?? [];
+  if (!allowedOps.some((op) => capabilityAllowsOp(caps, op))) {
+    throw new EngramAccessForbiddenError("token is not permitted to run the namespace preflight");
+  }
+}
+async function resolveNamespaceWritablePreflight(request, resolveWritable) {
+  try {
+    return { ok: true, namespace: await resolveWritable(request) };
+  } catch (error) {
+    if (error instanceof NamespaceNotWritableError) {
+      return { ok: false, reason: "not_writable", namespace: error.attemptedNamespace };
+    }
+    if (error instanceof EngramAccessInputError) {
+      return {
+        ok: false,
+        reason: "unsupported",
+        namespace: request.namespace?.trim() ?? ""
+      };
+    }
+    throw error;
+  }
+}
+async function resolveAuthorizedNamespaceWritablePreflight(caps, request, defaultNamespace, writeOp, resolvePreflight) {
+  if (!capabilityAllowsOp(caps, writeOp)) {
+    return {
+      ok: false,
+      reason: "not_writable",
+      namespace: request.namespace?.trim() || defaultNamespace
+    };
+  }
+  const result = await resolvePreflight(request);
+  if (!isNamespaceAllowed(caps, result.namespace, defaultNamespace)) {
+    return { ok: false, reason: "not_writable", namespace: result.namespace };
+  }
+  return result;
+}
+function resolveQueryNamespaceWritablePreflight(caps, params, authenticatedPrincipal, defaultNamespace, resolvePreflight) {
+  assertNamespacePreflightPermitted(caps);
+  return resolveAuthorizedNamespaceWritablePreflight(
+    caps,
+    namespaceWritableRequest(params, authenticatedPrincipal),
+    defaultNamespace,
+    parseNamespacePreflightWriteOp(params.get("op") ?? void 0),
+    resolvePreflight
+  );
+}
+
 // src/admin/admin-surfaces.ts
 import path7 from "path";
 var REDACTED = "<redacted>";
@@ -8623,6 +8960,13 @@ var EngramAccessService = class {
     });
     return { principal, codingContext, overlay, profilePlan };
   }
+  assertTokenCanWriteNamespace(namespace) {
+    enforceNamespaceAllowList(
+      tokenCapabilityStore.getStore(),
+      namespace,
+      this.orchestrator.config.defaultNamespace
+    );
+  }
   /**
    * Resolve the write namespace for explicit-write tools (memory_store /
    * suggestion_submit), project-scoping the write the same way recall does so a
@@ -8632,42 +8976,49 @@ var EngramAccessService = class {
    * (`canWriteNamespace` / profile-layer writability). Read-only: never mutates
    * session coding context.
    */
-  async resolveCodingScopedWriteNamespace(request) {
-    const hasExplicitNamespace = typeof request.namespace === "string" && request.namespace.trim().length > 0;
-    if (hasExplicitNamespace) {
-      return this.writableNamespaceFor(
-        request.namespace,
+  async resolveCodingScopedWriteNamespace(request, enforceToken = true) {
+    const requested = request.namespace?.trim();
+    if (requested) {
+      const namespace = this.writableNamespaceFor(
+        requested,
         request.sessionKey,
         request.authenticatedPrincipal
       );
+      if (enforceToken) this.assertTokenCanWriteNamespace(namespace);
+      return namespace;
     }
     const { principal, overlay, profilePlan } = await this.resolveCodingScopeInputs(request);
-    if (profilePlan) {
-      const selectedLayer = profilePlan.layers.find((layer) => layer.id === profilePlan.writeLayer);
-      const writeNamespaceReadable = profilePlan.writeNamespace.length > 0 && profilePlan.readNamespaces.includes(profilePlan.writeNamespace);
-      if (!selectedLayer?.writable || !writeNamespaceReadable) {
-        throw new NamespaceNotWritableError(
-          profilePlan.writeNamespace,
-          principal,
-          `scope profile ${profilePlan.profileId} has no writable layer for principal ${principal ?? "anonymous"}`
-        );
-      }
-      return profilePlan.writeNamespace;
+    const result = resolveScopedWritableNamespaceValue({
+      sessionKey: request.sessionKey,
+      authenticatedPrincipal: request.authenticatedPrincipal,
+      principal,
+      codingOverlay: overlay,
+      scopeProfile: profilePlan,
+      config: this.orchestrator.config
+    });
+    if (result.ok) {
+      if (enforceToken) this.assertTokenCanWriteNamespace(result.namespace);
+      return result.namespace;
     }
-    if (!overlay) {
-      return this.writableNamespaceFor(
-        void 0,
-        request.sessionKey,
-        request.authenticatedPrincipal
+    if (profilePlan && result.namespace === profilePlan.writeNamespace) {
+      throw new NamespaceNotWritableError(
+        result.namespace,
+        principal,
+        `scope profile ${profilePlan.profileId} has no writable layer for principal ${principal ?? "anonymous"}`
       );
     }
-    const base = defaultNamespaceForPrincipal(principal, this.orchestrator.config);
-    if (!canWriteNamespace(principal, base, this.orchestrator.config)) {
-      throw new NamespaceNotWritableError(base, principal);
+    if (result.reason === "unsupported") {
+      throw new EngramAccessInputError(`unsupported namespace: ${result.namespace}`);
     }
-    return combineNamespaces(base, overlay.namespace);
+    throw new NamespaceNotWritableError(result.namespace, principal);
+  }
+  async namespaceWritablePreflight(request) {
+    return resolveNamespaceWritablePreflight(
+      request,
+      (preflightRequest) => this.resolveCodingScopedWriteNamespace(preflightRequest, false)
+    );
   }
-  /** Read-side mirror of {@link resolveCodingScopedWriteNamespace}. Decision
+  /**
    *  `list`/`get` use this so a record written by a project-scoped session is
    *  listable/fetchable by the SAME session without manually supplying the
    *  overlaid namespace (review P2). Derivation is IDENTICAL to the write path
@@ -8738,6 +9089,7 @@ var EngramAccessService = class {
         request.sessionKey,
         request.authenticatedPrincipal
       );
+      this.assertTokenCanWriteNamespace(writeNamespace2);
       return {
         principal,
         explicitNamespace: request.namespace.trim(),
@@ -8772,6 +9124,14 @@ var EngramAccessService = class {
         this.orchestrator.setCodingContextForSession(request.sessionKey, null);
       }
     };
+    const assertWriteNamespaceAllowed = (namespace) => {
+      try {
+        this.assertTokenCanWriteNamespace(namespace);
+      } catch (error) {
+        clearSeededContext();
+        throw error;
+      }
+    };
     const overlaidBase = this.orchestrator.applyCodingNamespaceOverlay(
       request.sessionKey,
       baseNamespace
@@ -8814,6 +9174,7 @@ var EngramAccessService = class {
           (layer) => (layer.id === "userProject" || layer.id === "teamProject") && layer.readable && layer.namespace && readNamespaces2.includes(layer.namespace)
         )
       );
+      assertWriteNamespaceAllowed(profilePlan.writeNamespace);
       return {
         principal,
         baseNamespace: profilePlan.baseNamespace,
@@ -8839,6 +9200,7 @@ var EngramAccessService = class {
         clearSeededContext();
         throw new NamespaceNotWritableError(baseNamespace, principal);
       }
+      assertWriteNamespaceAllowed(writeNamespace2);
       return {
         principal,
         // scopeDebug.baseNamespace must report the principal SELF base
@@ -8867,6 +9229,7 @@ var EngramAccessService = class {
       const ns = combineNamespaces(baseNamespace, fallback);
       if (!readNamespaces.includes(ns)) readNamespaces.push(ns);
     }
+    assertWriteNamespaceAllowed(writeNamespace);
     return {
       principal,
       baseNamespace,
@@ -11992,6 +12355,21 @@ export {
   clusterByKey,
   computeProcedureStats,
   formatProcedureStatsText,
+  OPERATION_NAMES,
+  coerceBooleanLike,
+  coercePositiveInteger,
+  normalizeOptionalPath,
+  formatZodIssues,
+  defineOperation,
+  getOperation,
+  listRegisteredOperations,
+  __resetRegistryForTest,
+  namespaceWritableRequest,
+  parseNamespacePreflightWriteOp,
+  assertNamespacePreflightPermitted,
+  resolveNamespaceWritablePreflight,
+  resolveAuthorizedNamespaceWritablePreflight,
+  resolveQueryNamespaceWritablePreflight,
   AccessObserveWriteSurface,
   AccessLcmSurface,
   hasIdentityRecoveryIntent,
@@ -12007,4 +12385,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-3HYWNJDA.js.map
+//# sourceMappingURL=chunk-HWFK24UD.js.map