@subcortex-ai/sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1694 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AgentsNamespace: () => AgentsNamespace,
+  AssertionsNamespace: () => AssertionsNamespace,
+  CONTEXT_SCHEMA_VERSION: () => CONTEXT_SCHEMA_VERSION,
+  ConfidenceLevel: () => ConfidenceLevel,
+  ConfidenceScores: () => ConfidenceScores,
+  EntityPredicate: () => EntityPredicate,
+  EntityRelationship: () => EntityRelationship,
+  EventPredicate: () => EventPredicate,
+  IdentityPredicate: () => IdentityPredicate,
+  IntakeNamespace: () => IntakeNamespace,
+  MULTI_VALUE_PREDICATES: () => MULTI_VALUE_PREDICATES,
+  MemoryNamespace: () => MemoryNamespace,
+  MemoryPredicate: () => MemoryPredicate,
+  NEGATIVE_SIGNALS: () => NEGATIVE_SIGNALS,
+  OrgRelationship: () => OrgRelationship,
+  POSITIVE_SIGNALS: () => POSITIVE_SIGNALS,
+  Predicates: () => Predicates,
+  RELATIONSHIP_LABELS: () => RELATIONSHIP_LABELS,
+  REVERSE_RELATIONSHIPS: () => REVERSE_RELATIONSHIPS,
+  RapportPredicate: () => RapportPredicate,
+  RelationshipTypes: () => RelationshipTypes,
+  RelationshipsNamespace: () => RelationshipsNamespace,
+  SIGNAL_DECAY_CONFIG: () => SIGNAL_DECAY_CONFIG,
+  SYSTEM_SIGNAL_TYPES: () => SYSTEM_SIGNAL_TYPES,
+  SignalsNamespace: () => SignalsNamespace,
+  SubCortexAuthenticationError: () => SubCortexAuthenticationError,
+  SubCortexAuthorizationError: () => SubCortexAuthorizationError,
+  SubCortexClient: () => SubCortexClient,
+  SubCortexConflictError: () => SubCortexConflictError,
+  SubCortexError: () => SubCortexError,
+  SubCortexNetworkError: () => SubCortexNetworkError,
+  SubCortexNotFoundError: () => SubCortexNotFoundError,
+  SubCortexRateLimitError: () => SubCortexRateLimitError,
+  SubCortexServerError: () => SubCortexServerError,
+  SubCortexTimeoutError: () => SubCortexTimeoutError,
+  SubCortexValidationError: () => SubCortexValidationError,
+  SubjectPrefix: () => SubjectPrefix,
+  UsersNamespace: () => UsersNamespace,
+  WorkPredicate: () => WorkPredicate,
+  confidenceToScore: () => confidenceToScore,
+  formatContext: () => formatContext,
+  getDecayHalfLife: () => getDecayHalfLife,
+  isValidSignalType: () => isValidSignalType,
+  scoreToConfidence: () => scoreToConfidence,
+  subject: () => subject,
+  toContextXml: () => toContextXml
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var SubCortexError = class extends Error {
+  /** HTTP status code (0 for network errors) */
+  statusCode;
+  /** Server-assigned request ID for debugging */
+  requestId;
+  /** Whether the request can be retried */
+  retryable;
+  /** Raw response body */
+  body;
+  constructor(message, statusCode, options) {
+    super(message);
+    this.name = "SubCortexError";
+    this.statusCode = statusCode;
+    this.requestId = options?.requestId;
+    this.retryable = options?.retryable ?? false;
+    this.body = options?.body;
+  }
+};
+var SubCortexValidationError = class extends SubCortexError {
+  /** Field-level validation errors if available */
+  details;
+  constructor(message, options) {
+    super(message, 400, { ...options, retryable: false });
+    this.name = "SubCortexValidationError";
+    this.details = options?.details;
+  }
+};
+var SubCortexAuthenticationError = class extends SubCortexError {
+  constructor(message, options) {
+    super(message, 401, { ...options, retryable: false });
+    this.name = "SubCortexAuthenticationError";
+  }
+};
+var SubCortexAuthorizationError = class extends SubCortexError {
+  constructor(message, options) {
+    super(message, 403, { ...options, retryable: false });
+    this.name = "SubCortexAuthorizationError";
+  }
+};
+var SubCortexNotFoundError = class extends SubCortexError {
+  constructor(message, options) {
+    super(message, 404, { ...options, retryable: false });
+    this.name = "SubCortexNotFoundError";
+  }
+};
+var SubCortexConflictError = class extends SubCortexError {
+  constructor(message, options) {
+    super(message, 409, { ...options, retryable: false });
+    this.name = "SubCortexConflictError";
+  }
+};
+var SubCortexRateLimitError = class extends SubCortexError {
+  /** Seconds to wait before retrying */
+  retryAfter;
+  constructor(message, options) {
+    super(message, 429, { ...options, retryable: true });
+    this.name = "SubCortexRateLimitError";
+    this.retryAfter = options?.retryAfter;
+  }
+};
+var SubCortexServerError = class extends SubCortexError {
+  constructor(message, statusCode, options) {
+    super(message, statusCode, { ...options, retryable: true });
+    this.name = "SubCortexServerError";
+  }
+};
+var SubCortexNetworkError = class extends SubCortexError {
+  cause;
+  constructor(message, options) {
+    super(message, 0, { retryable: true });
+    this.name = "SubCortexNetworkError";
+    this.cause = options?.cause;
+  }
+};
+var SubCortexTimeoutError = class extends SubCortexNetworkError {
+  constructor(timeoutMs) {
+    super(`Request timed out after ${timeoutMs}ms`);
+    this.name = "SubCortexTimeoutError";
+  }
+};
+function classifyError(statusCode, body, requestId, retryAfterHint) {
+  let errorCode = "";
+  let message = "";
+  let details;
+  try {
+    const parsed = JSON.parse(body);
+    if (parsed.error) {
+      errorCode = parsed.error.code || "";
+      message = parsed.error.message || "";
+      if (parsed.error.details) {
+        details = parsed.error.details;
+      }
+    }
+  } catch {
+  }
+  if (!message) {
+    message = body || `HTTP ${statusCode}`;
+  }
+  const opts = { requestId, body };
+  switch (statusCode) {
+    case 400:
+      return new SubCortexValidationError(message, { ...opts, details });
+    case 401:
+      return new SubCortexAuthenticationError(message, opts);
+    case 403:
+      return new SubCortexAuthorizationError(message, opts);
+    case 404:
+      return new SubCortexNotFoundError(message, opts);
+    case 409:
+      return new SubCortexConflictError(message, opts);
+    case 429: {
+      let retryAfter = retryAfterHint;
+      if (retryAfter === void 0) {
+        try {
+          const parsed = JSON.parse(body);
+          retryAfter = parsed.retryAfter ?? parsed.retry_after;
+        } catch {
+        }
+      }
+      return new SubCortexRateLimitError(message, { ...opts, retryAfter });
+    }
+    default:
+      if (statusCode >= 500) {
+        return new SubCortexServerError(message, statusCode, opts);
+      }
+      return new SubCortexError(message, statusCode, opts);
+  }
+}
+
+// src/http.ts
+function snakeToCamel(s) {
+  return s.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function camelToSnake(s) {
+  return s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+function mapKeys(obj, mapper) {
+  if (obj === null || obj === void 0) return obj;
+  if (Array.isArray(obj)) return obj.map((item) => mapKeys(item, mapper));
+  if (typeof obj === "object") {
+    const mapped = {};
+    for (const [key, value] of Object.entries(obj)) {
+      mapped[mapper(key)] = mapKeys(value, mapper);
+    }
+    return mapped;
+  }
+  return obj;
+}
+function fromWire(data) {
+  return mapKeys(data, snakeToCamel);
+}
+function toWire(data) {
+  return mapKeys(data, camelToSnake);
+}
+var counter = 0;
+function generateRequestId() {
+  const ts = Date.now().toString(36);
+  const seq = (counter++).toString(36);
+  const rand = Math.random().toString(36).slice(2, 6);
+  return `scx-${ts}-${seq}-${rand}`;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function computeDelay(attempt, config) {
+  const exponential = config.baseDelayMs * Math.pow(2, attempt);
+  const capped = Math.min(exponential, config.maxDelayMs);
+  const jitter = capped * (0.5 + Math.random());
+  return Math.round(jitter);
+}
+function isRetryable(status) {
+  return status === 429 || status >= 500;
+}
+var HttpTransport = class {
+  opts;
+  constructor(options) {
+    this.opts = {
+      ...options,
+      baseUrl: options.baseUrl.replace(/\/$/, "")
+    };
+  }
+  /** GET request with retry and typed response. */
+  async get(path, tenantId) {
+    return this.request("GET", path, void 0, tenantId);
+  }
+  /** POST request with retry and typed response. */
+  async post(path, body, tenantId) {
+    return this.request("POST", path, body, tenantId);
+  }
+  /** PUT request with retry and typed response. */
+  async put(path, body, tenantId) {
+    return this.request("PUT", path, body, tenantId);
+  }
+  /** DELETE request with retry and typed response. */
+  async delete(path, tenantId) {
+    return this.request("DELETE", path, void 0, tenantId);
+  }
+  /** Core request method with retry loop. */
+  async request(method, path, body, tenantIdOverride) {
+    const url = `${this.opts.baseUrl}${path}`;
+    const requestId = generateRequestId();
+    const tenantId = tenantIdOverride || this.opts.tenantId;
+    const headers = {
+      Accept: "application/json",
+      "X-Request-ID": requestId,
+      "X-Tenant-ID": tenantId,
+      ...this.opts.headers
+    };
+    if (body !== void 0) {
+      headers["Content-Type"] = "application/json";
+    }
+    if (this.opts.apiKey) {
+      headers["Authorization"] = `Bearer ${this.opts.apiKey}`;
+    } else if (this.opts.token) {
+      headers["Authorization"] = `Bearer ${this.opts.token}`;
+    }
+    const fetchOpts = {
+      method,
+      headers,
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    };
+    let lastError;
+    for (let attempt = 0; attempt <= this.opts.retry.maxRetries; attempt++) {
+      try {
+        const response = await this.fetchWithTimeout(url, fetchOpts);
+        if (response.ok) {
+          const text = await response.text();
+          if (!text) return void 0;
+          const parsed = JSON.parse(text);
+          return fromWire(parsed);
+        }
+        const responseBody = await response.text();
+        if (response.status === 429) {
+          const retryAfterRaw = response.headers.get("Retry-After");
+          const retryAfterSecs = retryAfterRaw ? parseInt(retryAfterRaw, 10) : 0;
+          if (attempt < this.opts.retry.maxRetries) {
+            const delay = retryAfterSecs > 0 ? retryAfterSecs * 1e3 : computeDelay(attempt, this.opts.retry);
+            await sleep(delay);
+            lastError = classifyError(response.status, responseBody, requestId, retryAfterSecs || void 0);
+            continue;
+          }
+          throw classifyError(response.status, responseBody, requestId, retryAfterSecs || void 0);
+        }
+        if (isRetryable(response.status) && attempt < this.opts.retry.maxRetries) {
+          lastError = classifyError(response.status, responseBody, requestId);
+          await sleep(computeDelay(attempt, this.opts.retry));
+          continue;
+        }
+        throw classifyError(response.status, responseBody, requestId);
+      } catch (error) {
+        if (error instanceof Error && error.name.startsWith("SubCortex")) {
+          if (!error.retryable || attempt >= this.opts.retry.maxRetries) {
+            throw error;
+          }
+          lastError = error;
+          await sleep(computeDelay(attempt, this.opts.retry));
+          continue;
+        }
+        if (error instanceof TypeError || error instanceof DOMException) {
+          lastError = new SubCortexNetworkError(
+            `Network error: ${error.message}`,
+            { cause: error }
+          );
+          if (attempt < this.opts.retry.maxRetries) {
+            await sleep(computeDelay(attempt, this.opts.retry));
+            continue;
+          }
+          throw lastError;
+        }
+        throw error;
+      }
+    }
+    throw lastError || new SubCortexNetworkError("Request failed after all retries");
+  }
+  /** Fetch with AbortController timeout. */
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      this.opts.timeoutMs
+    );
+    if (this.opts.signal) {
+      this.opts.signal.addEventListener("abort", () => controller.abort());
+    }
+    try {
+      return await this.opts.fetchImpl(url, {
+        ...init,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError" && !this.opts.signal?.aborted) {
+        throw new SubCortexTimeoutError(this.opts.timeoutMs);
+      }
+      throw error;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+};
+
+// src/types/schema.ts
+var SubjectPrefix = /* @__PURE__ */ ((SubjectPrefix2) => {
+  SubjectPrefix2["USER"] = "user";
+  SubjectPrefix2["PERSON"] = "person";
+  SubjectPrefix2["ROLE"] = "role";
+  SubjectPrefix2["ENTITY"] = "entity";
+  SubjectPrefix2["PROPERTY"] = "property";
+  SubjectPrefix2["PROJECT"] = "project";
+  SubjectPrefix2["EVENT"] = "event";
+  SubjectPrefix2["AGENT"] = "agent";
+  return SubjectPrefix2;
+})(SubjectPrefix || {});
+var TITLE_NORMALIZATIONS = [
+  [/\bvp\b/gi, "Vice President"],
+  [/\bsvp\b/gi, "Senior Vice President"],
+  [/\bevp\b/gi, "Executive Vice President"],
+  [/\bcto\b/gi, "Chief Technology Officer"],
+  [/\bceo\b/gi, "Chief Executive Officer"],
+  [/\bcfo\b/gi, "Chief Financial Officer"],
+  [/\bcoo\b/gi, "Chief Operating Officer"],
+  [/\bcmo\b/gi, "Chief Marketing Officer"],
+  [/\bcpo\b/gi, "Chief Product Officer"],
+  [/\bcio\b/gi, "Chief Information Officer"],
+  [/\bea\b/gi, "Executive Assistant"],
+  [/\bpm\b/gi, "Project Manager"],
+  [/\bdir\b/gi, "Director"],
+  [/\bsr\b/gi, "Senior"],
+  [/\bjr\b/gi, "Junior"]
+];
+function subject(prefix, identifier) {
+  let expanded = identifier;
+  if (prefix === "role" /* ROLE */ || prefix === "role") {
+    for (const [pattern, replacement] of TITLE_NORMALIZATIONS) {
+      expanded = expanded.replace(pattern, replacement);
+    }
+  }
+  const normalized = expanded.toLowerCase().replace(/\s+/g, "-");
+  return `${prefix}:${normalized}`;
+}
+var IdentityPredicate = /* @__PURE__ */ ((IdentityPredicate2) => {
+  IdentityPredicate2["NAME"] = "name";
+  IdentityPredicate2["FULL_NAME"] = "full_name";
+  IdentityPredicate2["ROLE"] = "role";
+  IdentityPredicate2["TITLE"] = "title";
+  IdentityPredicate2["DEPARTMENT"] = "department";
+  IdentityPredicate2["TEAM"] = "team";
+  IdentityPredicate2["START_DATE"] = "start_date";
+  IdentityPredicate2["EMAIL"] = "email";
+  return IdentityPredicate2;
+})(IdentityPredicate || {});
+var WorkPredicate = /* @__PURE__ */ ((WorkPredicate2) => {
+  WorkPredicate2["EXPERTISE"] = "expertise";
+  WorkPredicate2["CURRENT_PROJECT"] = "current_project";
+  WorkPredicate2["PAIN_POINT"] = "pain_point";
+  return WorkPredicate2;
+})(WorkPredicate || {});
+var EventPredicate = /* @__PURE__ */ ((EventPredicate2) => {
+  EventPredicate2["STATUS"] = "status";
+  EventPredicate2["STATUS_CHANGE"] = "status_change";
+  EventPredicate2["EVENT"] = "event";
+  EventPredicate2["DECISION"] = "decision";
+  EventPredicate2["OUTCOME"] = "outcome";
+  return EventPredicate2;
+})(EventPredicate || {});
+var RapportPredicate = /* @__PURE__ */ ((RapportPredicate2) => {
+  RapportPredicate2["SENTIMENT"] = "sentiment";
+  RapportPredicate2["FRUSTRATION"] = "frustration";
+  RapportPredicate2["EXCITEMENT"] = "excitement";
+  RapportPredicate2["CONCERN"] = "concern";
+  RapportPredicate2["GOAL"] = "goal";
+  RapportPredicate2["ASPIRATION"] = "aspiration";
+  RapportPredicate2["PREFERENCE"] = "preference";
+  RapportPredicate2["PAIN_POINT"] = "pain_point";
+  RapportPredicate2["INTEREST"] = "interest";
+  RapportPredicate2["COMMUNICATION_STYLE"] = "communication_style";
+  return RapportPredicate2;
+})(RapportPredicate || {});
+var MemoryPredicate = /* @__PURE__ */ ((MemoryPredicate2) => {
+  MemoryPredicate2["REMINDER"] = "reminder";
+  MemoryPredicate2["CONTEXT"] = "context";
+  MemoryPredicate2["CONTEXT_TASK"] = "context:task";
+  MemoryPredicate2["CURRENT_PROJECT"] = "current_project";
+  return MemoryPredicate2;
+})(MemoryPredicate || {});
+var EntityPredicate = /* @__PURE__ */ ((EntityPredicate2) => {
+  EntityPredicate2["TYPE"] = "type";
+  EntityPredicate2["DESCRIPTION"] = "description";
+  EntityPredicate2["FIELD_TYPE"] = "field_type";
+  EntityPredicate2["REQUIRED"] = "required";
+  EntityPredicate2["WORKFLOW"] = "workflow";
+  return EntityPredicate2;
+})(EntityPredicate || {});
+var Predicates = {
+  ...IdentityPredicate,
+  ...WorkPredicate,
+  ...EventPredicate,
+  ...RapportPredicate,
+  ...MemoryPredicate,
+  ...EntityPredicate
+};
+var OrgRelationship = /* @__PURE__ */ ((OrgRelationship2) => {
+  OrgRelationship2["REPORTS_TO"] = "reports_to";
+  OrgRelationship2["MANAGES"] = "manages";
+  OrgRelationship2["MEMBER_OF"] = "member_of";
+  OrgRelationship2["HAS_MEMBER"] = "has_member";
+  OrgRelationship2["HOLDS_ROLE"] = "holds_role";
+  OrgRelationship2["CANDIDATE_FOR"] = "candidate_for";
+  OrgRelationship2["COLLABORATES_WITH"] = "collaborates_with";
+  OrgRelationship2["MENTORS"] = "mentors";
+  OrgRelationship2["MENTORED_BY"] = "mentored_by";
+  OrgRelationship2["STAKEHOLDER_IN"] = "stakeholder_in";
+  return OrgRelationship2;
+})(OrgRelationship || {});
+var EntityRelationship = /* @__PURE__ */ ((EntityRelationship2) => {
+  EntityRelationship2["HAS_PROPERTY"] = "has_property";
+  EntityRelationship2["BELONGS_TO"] = "belongs_to";
+  EntityRelationship2["HAS_MANY"] = "has_many";
+  EntityRelationship2["MANY_TO_MANY"] = "many_to_many";
+  EntityRelationship2["DEPENDS_ON"] = "depends_on";
+  return EntityRelationship2;
+})(EntityRelationship || {});
+var RelationshipTypes = {
+  ...OrgRelationship,
+  ...EntityRelationship
+};
+var ConfidenceLevel = /* @__PURE__ */ ((ConfidenceLevel2) => {
+  ConfidenceLevel2["CONFIRMED"] = "confirmed";
+  ConfidenceLevel2["HIGH"] = "high";
+  ConfidenceLevel2["MODERATE"] = "moderate";
+  ConfidenceLevel2["LOW"] = "low";
+  return ConfidenceLevel2;
+})(ConfidenceLevel || {});
+var ConfidenceScores = {
+  ["confirmed" /* CONFIRMED */]: 0.99,
+  ["high" /* HIGH */]: 0.85,
+  ["moderate" /* MODERATE */]: 0.65,
+  ["low" /* LOW */]: 0.4
+};
+function confidenceToScore(level) {
+  return ConfidenceScores[level] ?? 0.7;
+}
+function scoreToConfidence(score) {
+  if (score >= 0.95) return "confirmed" /* CONFIRMED */;
+  if (score >= 0.8) return "high" /* HIGH */;
+  if (score >= 0.6) return "moderate" /* MODERATE */;
+  return "low" /* LOW */;
+}
+var MULTI_VALUE_PREDICATES = /* @__PURE__ */ new Set([
+  // Events — multiple things happen over time
+  "status_change" /* STATUS_CHANGE */,
+  "event" /* EVENT */,
+  "decision" /* DECISION */,
+  "outcome" /* OUTCOME */,
+  // Emotional — multiple sentiments about different things
+  "sentiment" /* SENTIMENT */,
+  "frustration" /* FRUSTRATION */,
+  "excitement" /* EXCITEMENT */,
+  "concern" /* CONCERN */,
+  "goal" /* GOAL */,
+  "interest" /* INTEREST */,
+  // Memory — multiple reminders, contexts, projects
+  "reminder" /* REMINDER */,
+  "context:task" /* CONTEXT_TASK */,
+  "current_project" /* CURRENT_PROJECT */,
+  // Timeline
+  "timeline"
+]);
+var REVERSE_RELATIONSHIPS = {
+  // Proper OrgRelationship values
+  ["reports_to" /* REPORTS_TO */]: "manages" /* MANAGES */,
+  ["manages" /* MANAGES */]: "reports_to" /* REPORTS_TO */,
+  ["member_of" /* MEMBER_OF */]: "has_member" /* HAS_MEMBER */,
+  ["has_member" /* HAS_MEMBER */]: "member_of" /* MEMBER_OF */,
+  ["mentors" /* MENTORS */]: "mentored_by" /* MENTORED_BY */,
+  ["mentored_by" /* MENTORED_BY */]: "mentors" /* MENTORS */,
+  ["collaborates_with" /* COLLABORATES_WITH */]: "collaborates_with" /* COLLABORATES_WITH */,
+  ["candidate_for" /* CANDIDATE_FOR */]: "candidate_for" /* CANDIDATE_FOR */,
+  ["stakeholder_in" /* STAKEHOLDER_IN */]: "stakeholder_in" /* STAKEHOLDER_IN */,
+  // Agent-facing predicate names → proper relationship types
+  // The model sends 'direct_report' as predicate, SDK maps to proper relationships
+  "direct_report": "reports_to" /* REPORTS_TO */,
+  "team_member": "member_of" /* MEMBER_OF */,
+  "candidate": "candidate_for" /* CANDIDATE_FOR */,
+  "manager": "manages" /* MANAGES */,
+  "stakeholder": "stakeholder_in" /* STAKEHOLDER_IN */,
+  "collaborator": "collaborates_with" /* COLLABORATES_WITH */,
+  "mentor": "mentored_by" /* MENTORED_BY */
+};
+var RELATIONSHIP_LABELS = {
+  ["reports_to" /* REPORTS_TO */]: "reports to (person is a direct report)",
+  ["manages" /* MANAGES */]: "manages (user is the manager)",
+  ["member_of" /* MEMBER_OF */]: "is a member of (team, project)",
+  ["holds_role" /* HOLDS_ROLE */]: "holds a role/position",
+  ["candidate_for" /* CANDIDATE_FOR */]: "is a candidate for a role",
+  ["collaborates_with" /* COLLABORATES_WITH */]: "collaborates with",
+  ["mentors" /* MENTORS */]: "mentors",
+  ["stakeholder_in" /* STAKEHOLDER_IN */]: "is a stakeholder in"
+};
+
+// src/types/signals.ts
+var SYSTEM_SIGNAL_TYPES = [
+  "frustration",
+  "excitement",
+  "concern",
+  "satisfaction",
+  "confusion",
+  "gratitude",
+  "tension",
+  "sentiment"
+];
+function isValidSignalType(type) {
+  if (SYSTEM_SIGNAL_TYPES.includes(type)) return true;
+  if (type.startsWith("custom:")) return true;
+  return false;
+}
+var SIGNAL_DECAY_CONFIG = {
+  frustration: 24,
+  excitement: 24,
+  concern: 24,
+  satisfaction: 24,
+  confusion: 24,
+  gratitude: 24,
+  tension: 24,
+  sentiment: 24,
+  _default: 24
+};
+function getDecayHalfLife(signalType) {
+  return SIGNAL_DECAY_CONFIG[signalType] ?? SIGNAL_DECAY_CONFIG._default;
+}
+var POSITIVE_SIGNALS = /* @__PURE__ */ new Set([
+  "satisfaction",
+  "excitement",
+  "gratitude"
+]);
+var NEGATIVE_SIGNALS = /* @__PURE__ */ new Set([
+  "frustration",
+  "concern",
+  "tension",
+  "confusion"
+]);
+
+// src/signals.ts
+var LEGACY_SIGNAL_PREDICATES = /* @__PURE__ */ new Set([
+  "sentiment",
+  "frustration",
+  "excitement",
+  "concern",
+  "goal",
+  "aspiration",
+  "preference",
+  "interest"
+]);
+var SignalsNamespace = class {
+  constructor(http, tenantId) {
+    this.http = http;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Record an emotional signal about a user.
+   *
+   * @example
+   * ```typescript
+   * await brain.signals.record({
+   *   userId: 'cmk123',
+   *   type: 'frustration',
+   *   content: 'Frustrated about the hiring timeline',
+   *   intensity: 0.85,
+   *   aboutSubject: 'context:hiring-ea',
+   * })
+   * ```
+   */
+  async record(input) {
+    if (!isValidSignalType(input.type)) {
+      throw new Error(`Invalid signal type: ${input.type}. Use one of: ${SYSTEM_SIGNAL_TYPES.join(", ")} or custom:{tenant}:{type}`);
+    }
+    const userSubject = subject("user" /* USER */, input.userId);
+    const predicate = `signal:${input.type}`;
+    const value = {
+      content: input.content,
+      intensity: input.intensity ?? 0.7,
+      about_subject: input.aboutSubject || null,
+      session_id: input.sessionId || null
+    };
+    const result = await this.http.post("/api/v1/assertions", {
+      tenant_id: this.tenantId,
+      subject: userSubject,
+      predicate,
+      value,
+      confidence: input.intensity ?? 0.7
+    });
+    let resolved = 0;
+    if (input.resolveConflicting && POSITIVE_SIGNALS.has(input.type)) {
+      try {
+        const snapshot = await this.query(userSubject, { windowHours: 72 });
+        for (const sig of snapshot.signals) {
+          if (!NEGATIVE_SIGNALS.has(sig.type)) continue;
+          if (sig.resolvedBy) continue;
+          const sameContext = input.aboutSubject ? sig.aboutSubject === input.aboutSubject : !sig.aboutSubject;
+          if (sameContext) {
+            await this.resolve({ signalId: sig.id, resolvedBySignalId: result.id });
+            resolved++;
+          }
+        }
+      } catch {
+      }
+    }
+    return { id: result.id, ...resolved > 0 && { resolved } };
+  }
+  /**
+   * Query signals for a user with computed decay and trajectory.
+   * Delegates to the engine's signal query endpoint for server-side computation.
+   *
+   * @example
+   * ```typescript
+   * const snapshot = await brain.signals.query('user:cmk123', {
+   *   windowHours: 72,
+   *   type: 'frustration',
+   * })
+   * ```
+   */
+  async query(userSubject, options = {}) {
+    const windowHours = options.windowHours ?? 72;
+    const query = { window: String(windowHours) };
+    if (options.type) query.type = options.type;
+    const qs = new URLSearchParams(query).toString();
+    const response = await this.http.get(
+      `/api/v1/signals/${enc(this.tenantId)}/${enc(userSubject)}?${qs}`
+    );
+    const signals = response.signals.map((s) => ({
+      id: s.assertion_id,
+      type: s.signal_type,
+      content: s.content,
+      intensity: s.intensity,
+      decayedIntensity: s.decayed_intensity,
+      ageHours: Math.round(s.age_hours * 10) / 10,
+      aboutSubject: s.about_subject || void 0,
+      resolvedBy: s.resolved_by || void 0,
+      timestamp: s.timestamp
+    }));
+    return {
+      signals,
+      trajectory: response.trajectory,
+      aggregateIntensity: response.aggregate_intensity
+    };
+  }
+  /**
+   * Resolve a signal — mark it as resolved by a subsequent positive interaction.
+   * The resolved signal's effective intensity drops faster.
+   *
+   * @example
+   * ```typescript
+   * await brain.signals.resolve({
+   *   signalId: 'abc123',
+   *   resolvedBySignalId: 'def456',
+   * })
+   * ```
+   */
+  async resolve(input) {
+    const original = await this.http.get(
+      `/api/v1/assertions/${enc(this.tenantId)}/${enc(input.signalId)}`
+    ).catch(() => null);
+    if (!original) return { success: false };
+    const value = typeof original.value === "object" && original.value !== null ? { ...original.value, resolved_by: input.resolvedBySignalId } : { content: String(original.value), resolved_by: input.resolvedBySignalId };
+    await this.http.post("/api/v1/assertions/supersede", {
+      tenant_id: this.tenantId,
+      original_assertion_id: input.signalId,
+      subject: original.subject,
+      predicate: original.predicate,
+      value,
+      confidence: original.confidence
+    });
+    return { success: true };
+  }
+};
+function computeDecay(intensity, ageHours, halfLifeHours, isResolved = false) {
+  const effectiveHalfLife = isResolved ? halfLifeHours / 4 : halfLifeHours;
+  const decayed = intensity * Math.pow(2, -ageHours / effectiveHalfLife);
+  return Math.round(decayed * 100) / 100;
+}
+function extractSignals(assertions, windowHours = 72) {
+  const now = Date.now();
+  const windowMs = windowHours * 60 * 60 * 1e3;
+  const entries = [];
+  for (const a of assertions) {
+    if (a.isSuperseded) continue;
+    const isSignal = a.predicate.startsWith("signal:");
+    const isLegacy = LEGACY_SIGNAL_PREDICATES.has(a.predicate);
+    if (!isSignal && !isLegacy) continue;
+    const timestamp = a.validFrom;
+    const ageMs = now - new Date(timestamp).getTime();
+    if (ageMs > windowMs) continue;
+    const ageHours = ageMs / (60 * 60 * 1e3);
+    const type = isSignal ? a.predicate.slice(7) : a.predicate;
+    const halfLife = getDecayHalfLife(type);
+    let content = "";
+    let intensity = a.confidence ?? 0.7;
+    let aboutSubject;
+    let resolvedBy;
+    if (typeof a.value === "object" && a.value !== null) {
+      const v = a.value;
+      content = v.content || "";
+      intensity = v.intensity ?? intensity;
+      aboutSubject = v.about_subject || void 0;
+      resolvedBy = v.resolved_by || void 0;
+    } else {
+      content = String(a.value);
+    }
+    entries.push({
+      id: a.id,
+      type,
+      content,
+      intensity,
+      decayedIntensity: computeDecay(intensity, ageHours, halfLife, !!resolvedBy),
+      ageHours: Math.round(ageHours * 10) / 10,
+      aboutSubject,
+      resolvedBy,
+      timestamp
+    });
+  }
+  entries.sort((a, b) => a.ageHours - b.ageHours);
+  return entries;
+}
+function enc(s) {
+  return encodeURIComponent(s);
+}
+
+// src/users.ts
+var UsersNamespace = class {
+  constructor(http, tenantId) {
+    this.http = http;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Identify a user and retrieve their full context.
+   *
+   * This is the FIRST thing an agent should call at session start.
+   * Returns whether the user is known, their memories, connected
+   * people, reminders, conflicts, and a summary.
+   *
+   * @example
+   * ```typescript
+   * const user = await brain.users.identify({
+   *   userId: 'cmk123...',
+   *   displayName: 'Tom Santos',
+   * })
+   *
+   * if (!user.isKnown) {
+   *   // First encounter — get to know them
+   * } else {
+   *   // Returning user — reference what you know
+   *   // user.reminders — bring these up
+   *   // user.conflicts — address these
+   *   // user.connectedPeople — context about their org
+   * }
+   * ```
+   */
+  async identify(input) {
+    const userSubject = subject("user" /* USER */, input.userId);
+    const assertions = await this.http.get(
+      `/api/v1/assertions/query/${enc2(this.tenantId)}/${enc2(userSubject)}`
+    );
+    const active = assertions.filter((a) => !a.isSuperseded);
+    const isKnown = active.length > 0;
+    if (input.displayName && !active.some((a) => a.predicate === "name" || a.predicate === "full_name")) {
+      try {
+        await this.http.post("/api/v1/assertions", {
+          tenant_id: this.tenantId,
+          subject: userSubject,
+          predicate: "name",
+          value: input.displayName,
+          confidence: 1
+        });
+      } catch {
+      }
+    }
+    const nameAssertion = active.find((a) => a.predicate === "name" || a.predicate === "full_name");
+    const name = nameAssertion?.value || input.displayName || null;
+    const reminders = active.filter((a) => a.predicate === "reminder").map((a) => ({ id: a.id, predicate: a.predicate, value: a.value, confidence: a.confidence, createdAt: a.validFrom }));
+    for (const reminder of reminders) {
+      try {
+        await this.http.post(
+          `/api/v1/assertions/retract/${enc2(this.tenantId)}/${enc2(reminder.id)}`,
+          {}
+        );
+      } catch {
+      }
+    }
+    const contexts = active.filter((a) => a.predicate === "context" || a.predicate === "context:task").map((a) => ({ id: a.id, predicate: a.predicate, value: a.value, confidence: a.confidence, createdAt: a.validFrom }));
+    const signals = extractSignals(assertions);
+    const signalIds = new Set(signals.map((s) => s.id));
+    let rapportTrajectory = "neutral";
+    try {
+      const qs = new URLSearchParams({ window: "72" }).toString();
+      const snapshot = await this.http.get(
+        `/api/v1/signals/${enc2(this.tenantId)}/${enc2(userSubject)}?${qs}`
+      );
+      rapportTrajectory = snapshot.trajectory;
+    } catch {
+    }
+    const memories = active.filter(
+      (a) => a.predicate !== "reminder" && a.predicate !== "context" && a.predicate !== "context:task" && !signalIds.has(a.id)
+      // exclude signals from memories
+    ).map((a) => ({ id: a.id, predicate: a.predicate, value: a.value, confidence: a.confidence, createdAt: a.validFrom }));
+    const connectedPeople = [];
+    try {
+      const relationships = await this.http.get(`/api/v1/relationships/${enc2(this.tenantId)}/${enc2(userSubject)}`);
+      const visited = /* @__PURE__ */ new Set();
+      for (const rel of relationships) {
+        const other = rel.fromSubject === userSubject ? rel.toSubject : rel.fromSubject;
+        if (!other || other === userSubject || visited.has(other)) continue;
+        visited.add(other);
+        const personAssertions = await this.http.get(
+          `/api/v1/assertions/query/${enc2(this.tenantId)}/${enc2(other)}`
+        );
+        const personActive = personAssertions.filter((a) => !a.isSuperseded);
+        const personName = personActive.find((a) => a.predicate === "name");
+        const facts = personActive.filter((a) => a.predicate !== "name").map((a) => ({ predicate: a.predicate, value: a.value }));
+        connectedPeople.push({
+          subject: other,
+          name: personName?.value || other,
+          relationship: rel.relationshipType,
+          facts
+        });
+      }
+    } catch {
+    }
+    const conflicts = [];
+    try {
+      if (!input.agentId) throw new Error("agentId is required on IdentifyUserInput to fetch conflicts");
+      const pending = await this.http.get(`/api/v1/intake/pending/${enc2(input.agentId)}?status=conflict_detected`);
+      for (const item of pending) {
+        if (item.acknowledged) continue;
+        const hint = item.surfacingHint || "";
+        const involvesUser = hint.includes(userSubject) || (item.persistedAssertionIds || []).some((id) => {
+          const a = assertions.find((a2) => a2.id === id);
+          return a?.subject === userSubject;
+        });
+        if (!involvesUser) continue;
+        let resolvedHint = hint || "A conflict was detected.";
+        if (name) {
+          resolvedHint = resolvedHint.replace(
+            new RegExp(userSubject.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "g"),
+            name
+          );
+        }
+        conflicts.push({ id: item.id, hint: resolvedHint });
+      }
+    } catch {
+    }
+    const parts = [];
+    if (conflicts.length > 0) {
+      parts.push(`ATTENTION: ${conflicts.length} knowledge conflict(s) \u2014 MUST address: ${conflicts.map((c) => c.hint).join(" | ")}`);
+    }
+    if (reminders.length > 0) {
+      parts.push(`REMINDERS (${reminders.length}): ${reminders.map((r) => `"${r.value}"`).join(", ")}. Dismiss each after surfacing.`);
+    }
+    if (connectedPeople.length > 0) {
+      parts.push(`Connected people:
+${connectedPeople.map((p) => {
+        const factsStr = p.facts.map((f) => `${f.predicate}: ${f.value}`).join(", ");
+        return `- ${p.name} (${p.relationship})${factsStr ? ": " + factsStr : ""}`;
+      }).join("\n")}`);
+    }
+    if (memories.length > 0 && parts.length === 0) {
+      parts.push(`You know ${memories.length} things about this user.`);
+    }
+    if (parts.length === 0) {
+      parts.push("This is a new user \u2014 no memories yet. Get to know them.");
+    }
+    return {
+      subject: userSubject,
+      isKnown,
+      name,
+      memories,
+      connectedPeople,
+      reminders,
+      contexts,
+      conflicts,
+      signals,
+      rapportTrajectory,
+      summary: parts.join("\n")
+    };
+  }
+  /**
+   * Register a person that the user mentioned.
+   *
+   * Creates the person node, their role, and bidirectional
+   * relationships to the user. One call does everything.
+   *
+   * @example
+   * ```typescript
+   * const result = await brain.users.registerPerson({
+   *   name: 'John Smith',
+   *   userId: 'cmk123...',
+   *   relationship: 'direct_report',
+   *   role: 'VP of Engineering',
+   * })
+   * ```
+   */
+  async registerPerson(input) {
+    const userSubject = subject("user" /* USER */, input.userId);
+    const personSubject = subject("person" /* PERSON */, input.name);
+    const conf = typeof input.confidence === "number" ? input.confidence : confidenceToScore(input.confidence || "confirmed" /* CONFIRMED */);
+    let assertionsCreated = 0;
+    let relationshipsCreated = 0;
+    const warnings = [];
+    await this.http.post("/api/v1/assertions", {
+      tenant_id: this.tenantId,
+      subject: personSubject,
+      predicate: "name",
+      value: input.name,
+      confidence: conf
+    });
+    assertionsCreated++;
+    if (input.role) {
+      try {
+        const existing = await this.http.get(
+          `/api/v1/assertions/query/${enc2(this.tenantId)}/${enc2(personSubject)}`
+        );
+        const existingRole = existing.find((a) => a.predicate === "role" && !a.isSuperseded);
+        if (existingRole && existingRole.value !== input.role) {
+          warnings.push(`${input.name} was previously "${existingRole.value}" \u2014 now being set as "${input.role}". Role change or mistake?`);
+          await this.http.post("/api/v1/assertions/supersede", {
+            tenant_id: this.tenantId,
+            original_assertion_id: existingRole.id,
+            subject: personSubject,
+            predicate: "role",
+            value: input.role,
+            confidence: conf
+          });
+        } else if (!existingRole) {
+          await this.http.post("/api/v1/assertions", {
+            tenant_id: this.tenantId,
+            subject: personSubject,
+            predicate: "role",
+            value: input.role,
+            confidence: conf
+          });
+        }
+      } catch {
+        await this.http.post("/api/v1/assertions", {
+          tenant_id: this.tenantId,
+          subject: personSubject,
+          predicate: "role",
+          value: input.role,
+          confidence: conf
+        });
+      }
+      assertionsCreated++;
+      try {
+        const allAssertions = await this.http.get(
+          `/api/v1/assertions/list/${enc2(this.tenantId)}`
+        );
+        const sameRole = allAssertions.filter(
+          (a) => a.subject.startsWith("person:") && a.subject !== personSubject && a.predicate === "role" && a.value === input.role && !a.isSuperseded
+        );
+        if (sameRole.length > 0) {
+          const otherAssertions = await this.http.get(
+            `/api/v1/assertions/query/${enc2(this.tenantId)}/${enc2(sameRole[0].subject)}`
+          );
+          const otherName = otherAssertions.find((a) => a.predicate === "name")?.value || sameRole[0].subject;
+          warnings.push(`"${input.role}" is already held by ${otherName}. Is ${otherName} no longer in this role?`);
+        }
+      } catch {
+      }
+      const roleSubject = subject("role" /* ROLE */, input.role);
+      await this.http.post("/api/v1/assertions", {
+        tenant_id: this.tenantId,
+        subject: roleSubject,
+        predicate: "name",
+        value: input.role,
+        confidence: conf
+      });
+      await this.http.post("/api/v1/relationships", {
+        tenant_id: this.tenantId,
+        from_subject: personSubject,
+        to_subject: roleSubject,
+        relationship_type: "holds_role" /* HOLDS_ROLE */,
+        confidence: conf
+      });
+      assertionsCreated++;
+      relationshipsCreated++;
+    }
+    if (input.details) {
+      await this.http.post("/api/v1/assertions", {
+        tenant_id: this.tenantId,
+        subject: personSubject,
+        predicate: "details",
+        value: input.details,
+        confidence: conf
+      });
+      assertionsCreated++;
+    }
+    await this.http.post("/api/v1/assertions", {
+      tenant_id: this.tenantId,
+      subject: personSubject,
+      predicate: "status",
+      value: input.relationship === "candidate" ? "candidate" : "active",
+      confidence: conf
+    });
+    assertionsCreated++;
+    const FORWARD_MAP = {
+      "direct_report": "manages" /* MANAGES */,
+      "team_member": "has_member" /* HAS_MEMBER */,
+      "candidate": "manages" /* MANAGES */,
+      // user manages the hiring
+      "manager": "reports_to" /* REPORTS_TO */,
+      // user reports to this person
+      "stakeholder": "stakeholder_in" /* STAKEHOLDER_IN */,
+      "collaborator": "collaborates_with" /* COLLABORATES_WITH */,
+      "mentor": "mentors" /* MENTORS */
+    };
+    const forwardType = FORWARD_MAP[input.relationship] || input.relationship;
+    const reverseType = REVERSE_RELATIONSHIPS[input.relationship] || REVERSE_RELATIONSHIPS[forwardType] || input.relationship;
+    await this.http.post("/api/v1/relationships", {
+      tenant_id: this.tenantId,
+      from_subject: userSubject,
+      to_subject: personSubject,
+      relationship_type: forwardType,
+      confidence: conf
+    });
+    relationshipsCreated++;
+    await this.http.post("/api/v1/relationships", {
+      tenant_id: this.tenantId,
+      from_subject: personSubject,
+      to_subject: userSubject,
+      relationship_type: reverseType,
+      confidence: conf
+    });
+    relationshipsCreated++;
+    return { personSubject, assertionsCreated, relationshipsCreated, warnings };
+  }
+  /**
+   * Record an emotional state or rapport signal about the user.
+   *
+   * @example
+   * ```typescript
+   * await brain.users.recordRapport({
+   *   userId: 'cmk123...',
+   *   type: 'frustration',
+   *   value: 'Frustrated about losing the EA candidate',
+   *   aboutPerson: 'Sarah Johnson',
+   * })
+   * ```
+   */
+  async recordRapport(input) {
+    const userSubject = subject("user" /* USER */, input.userId);
+    const conf = typeof input.confidence === "number" ? input.confidence : confidenceToScore(input.confidence || "high" /* HIGH */);
+    await this.http.post("/api/v1/assertions", {
+      tenant_id: this.tenantId,
+      subject: userSubject,
+      predicate: input.type,
+      value: input.value,
+      confidence: conf
+    });
+    if (input.aboutPerson) {
+      const personSubject = subject("person" /* PERSON */, input.aboutPerson);
+      try {
+        const personAssertions = await this.http.get(
+          `/api/v1/assertions/query/${enc2(this.tenantId)}/${enc2(personSubject)}`
+        );
+        if (personAssertions.length > 0) {
+          await this.http.post("/api/v1/assertions", {
+            tenant_id: this.tenantId,
+            subject: personSubject,
+            predicate: "timeline",
+            value: input.value,
+            confidence: conf
+          });
+        }
+      } catch {
+      }
+    }
+    return { success: true };
+  }
+  /**
+   * Dismiss a reminder after the agent has surfaced it.
+   */
+  async dismissReminder(userId, reminderContent) {
+    const userSubject = subject("user" /* USER */, userId);
+    const assertions = await this.http.get(
+      `/api/v1/assertions/query/${enc2(this.tenantId)}/${enc2(userSubject)}`
+    );
+    const reminder = assertions.find(
+      (a) => a.predicate === "reminder" && !a.isSuperseded && a.value.toLowerCase().includes(reminderContent.toLowerCase())
+    );
+    if (reminder) {
+      await this.http.post(`/api/v1/assertions/retract/${enc2(this.tenantId)}/${enc2(reminder.id)}`, {});
+      return { success: true };
+    }
+    return { success: false };
+  }
+};
+function enc2(s) {
+  return encodeURIComponent(s);
+}
+
+// src/client.ts
+var AssertionsNamespace = class {
+  constructor(http, tenantId) {
+    this.http = http;
+    this.tenantId = tenantId;
+  }
+  /** Create an assertion in the knowledge graph. */
+  async create(input) {
+    const tenantId = input.tenantId || this.tenantId;
+    return this.http.post("/api/v1/assertions", {
+      tenant_id: tenantId,
+      subject: input.subject,
+      predicate: input.predicate,
+      value: input.value,
+      confidence: input.confidence
+    });
+  }
+  /** Get an assertion by its content-addressable ID. */
+  async get(assertionId, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/assertions/${enc3(tenantId)}/${enc3(assertionId)}`
+    );
+  }
+  /** Query assertions by subject. */
+  async query(subject2, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/assertions/query/${enc3(tenantId)}/${enc3(subject2)}`
+    );
+  }
+  /** List all active assertions for the tenant. */
+  async list(options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/assertions/list/${enc3(tenantId)}`
+    );
+  }
+  /** Supersede an existing assertion with updated values. */
+  async supersede(input) {
+    const tenantId = input.tenantId || this.tenantId;
+    return this.http.post("/api/v1/assertions/supersede", {
+      tenant_id: tenantId,
+      original_assertion_id: input.originalAssertionId,
+      subject: input.subject,
+      predicate: input.predicate,
+      value: input.value,
+      confidence: input.confidence
+    });
+  }
+  /** Retract an assertion by closing its temporal bounds. */
+  async retract(assertionId, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.post(
+      `/api/v1/assertions/retract/${enc3(tenantId)}/${enc3(assertionId)}`,
+      {}
+    );
+  }
+};
+var RelationshipsNamespace = class {
+  constructor(http, tenantId) {
+    this.http = http;
+    this.tenantId = tenantId;
+  }
+  /** Create a relationship between two subjects. */
+  async create(input) {
+    const tenantId = input.tenantId || this.tenantId;
+    return this.http.post("/api/v1/relationships", {
+      tenant_id: tenantId,
+      from_subject: input.fromSubject,
+      to_subject: input.toSubject,
+      relationship_type: input.relationshipType,
+      confidence: input.confidence,
+      weight: input.weight,
+      properties: input.properties
+    });
+  }
+  /** Get relationships for a subject. */
+  async query(subject2, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/relationships/${enc3(tenantId)}/${enc3(subject2)}`
+    );
+  }
+  /** List all relationships for the tenant. */
+  async list(options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/relationships/list/${enc3(tenantId)}`
+    );
+  }
+};
+var AgentsNamespace = class {
+  constructor(http, tenantId) {
+    this.http = http;
+    this.tenantId = tenantId;
+  }
+  /** Create a new agent. */
+  async create(input) {
+    const tenantId = input.tenantId || this.tenantId;
+    return this.http.post("/api/v1/agents", {
+      tenant_id: tenantId,
+      name: input.name,
+      description: input.description,
+      personality: input.personality,
+      instructions: input.instructions ? toWire(input.instructions) : void 0,
+      model: input.model ? toWire(input.model) : void 0,
+      capabilities: input.capabilities,
+      memory_policy: input.memoryPolicy ? toWire(input.memoryPolicy) : void 0
+    });
+  }
+  /** Get an agent by ID. */
+  async get(agentId, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/agents/${enc3(tenantId)}/${enc3(agentId)}`
+    );
+  }
+  /** Update an agent. */
+  async update(agentId, input, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.put(
+      `/api/v1/agents/${enc3(tenantId)}/${enc3(agentId)}`,
+      {
+        tenant_id: tenantId,
+        name: input.name,
+        description: input.description,
+        personality: input.personality,
+        instructions: input.instructions ? toWire(input.instructions) : void 0,
+        model: input.model ? toWire(input.model) : void 0,
+        capabilities: input.capabilities,
+        memory_policy: input.memoryPolicy ? toWire(input.memoryPolicy) : void 0,
+        is_active: input.isActive
+      }
+    );
+  }
+  /** Delete an agent. */
+  async delete(agentId, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    await this.http.delete(`/api/v1/agents/${enc3(tenantId)}/${enc3(agentId)}`);
+  }
+  /** List all agents for the tenant. */
+  async list(options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/agents/list/${enc3(tenantId)}`
+    );
+  }
+  /** Get composed system instructions for an agent. */
+  async getInstructions(agentId, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/agents/${enc3(tenantId)}/${enc3(agentId)}/instructions`
+    );
+  }
+};
+var MemoryNamespace = class {
+  constructor(http, tenantId) {
+    this.http = http;
+    this.tenantId = tenantId;
+  }
+  /**
+   * Store a fact in the agent's memory.
+   *
+   * Routes through the Thalamus by default. The Thalamus will:
+   * - Classify the signal (reject noise)
+   * - Check for contradictions with existing assertions
+   * - Detect duplicates and reinforce instead of creating new
+   *
+   * Pass `raw: true` to bypass Thalamus for system operations.
+   */
+  async store(input) {
+    const tenantId = input.tenantId || this.tenantId;
+    if (input.raw) {
+      return this.http.post("/api/v1/assertions", {
+        tenant_id: tenantId,
+        subject: input.subject,
+        predicate: input.predicate,
+        value: input.value,
+        confidence: input.confidence
+      });
+    }
+    const correlationId = `mem_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`;
+    return this.http.post("/api/v1/intake/submit", {
+      correlation_id: correlationId,
+      agent_id: input.agentId,
+      tenant_id: tenantId,
+      candidates: [{
+        subject: input.subject,
+        predicate: input.predicate,
+        value: input.value,
+        source_confidence: input.confidence ?? 0.95,
+        provenance: "agent",
+        person_name: input.personName
+      }],
+      context: input.context
+    });
+  }
+  /** Recall all memories for a subject. */
+  async recall(subject2, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.get(
+      `/api/v1/assertions/query/${enc3(tenantId)}/${enc3(subject2)}`
+    );
+  }
+  /** Forget a specific memory (retract the assertion). */
+  async forget(assertionId, options) {
+    const tenantId = options?.tenantId || this.tenantId;
+    return this.http.post(
+      `/api/v1/assertions/retract/${enc3(tenantId)}/${enc3(assertionId)}`,
+      {}
+    );
+  }
+};
+var IntakeNamespace = class {
+  constructor(http, tenantId) {
+    this.http = http;
+    this.tenantId = tenantId;
+  }
+  /** Submit candidate assertions for Thalamus processing. */
+  async submit(input) {
+    const tenantId = input.tenantId || this.tenantId;
+    return this.http.post("/api/v1/intake/submit", {
+      correlation_id: input.correlationId,
+      agent_id: input.agentId,
+      tenant_id: tenantId,
+      candidates: input.candidates.map((c) => ({
+        subject: c.subject,
+        predicate: c.predicate,
+        value: c.value,
+        source_confidence: c.sourceConfidence,
+        valid_from: c.validFrom,
+        valid_until: c.validUntil,
+        provenance: c.provenance,
+        person_name: c.personName
+      })),
+      context: input.context
+    });
+  }
+  /** Get pending intake results for an agent. */
+  async pending(agentId, options) {
+    let path = `/api/v1/intake/pending/${enc3(agentId)}`;
+    const params = [];
+    if (options?.status) params.push(`status=${options.status.join(",")}`);
+    if (options?.limit) params.push(`limit=${options.limit}`);
+    if (params.length) path += `?${params.join("&")}`;
+    return this.http.get(path);
+  }
+  /** Acknowledge an intake result (mark as consumed). */
+  async acknowledge(itemId) {
+    await this.http.post(`/api/v1/intake/acknowledge/${enc3(itemId)}`, {});
+  }
+  /** Acknowledge all pending items for an agent. */
+  async acknowledgeAll(agentId) {
+    return this.http.post(
+      `/api/v1/intake/acknowledge-all/${enc3(agentId)}`,
+      {}
+    );
+  }
+  /** Get intake processing stats for an agent. */
+  async stats(agentId) {
+    return this.http.get(`/api/v1/intake/stats/${enc3(agentId)}`);
+  }
+};
+var DEFAULT_RETRY = {
+  maxRetries: 3,
+  baseDelayMs: 500,
+  maxDelayMs: 1e4
+};
+var SubCortexClient = class {
+  /** Assertion operations (low-level knowledge primitives) */
+  assertions;
+  /** Relationship operations */
+  relationships;
+  /** Agent identity & configuration */
+  agents;
+  /** Agent memory (semantic wrapper over assertions) */
+  memory;
+  /** Thalamus cognitive intake pipeline */
+  intake;
+  /** User rapport building operations */
+  users;
+  /** Emotional signals — record, query, and resolve */
+  signals;
+  http;
+  constructor(options) {
+    if (!options.apiKey && !options.token) {
+      console.warn("[SubCortex] No apiKey or token provided \u2014 requests will be unauthenticated.");
+    }
+    this.http = new HttpTransport({
+      baseUrl: options.endpoint,
+      tenantId: options.tenantId,
+      apiKey: options.apiKey,
+      token: options.token,
+      retry: { ...DEFAULT_RETRY, ...options.retry },
+      timeoutMs: options.timeoutMs ?? 3e4,
+      fetchImpl: options.fetch ?? globalThis.fetch,
+      headers: options.headers ?? {},
+      signal: options.signal
+    });
+    this.assertions = new AssertionsNamespace(this.http, options.tenantId);
+    this.relationships = new RelationshipsNamespace(this.http, options.tenantId);
+    this.agents = new AgentsNamespace(this.http, options.tenantId);
+    this.memory = new MemoryNamespace(this.http, options.tenantId);
+    this.intake = new IntakeNamespace(this.http, options.tenantId);
+    this.users = new UsersNamespace(this.http, options.tenantId);
+    this.signals = new SignalsNamespace(this.http, options.tenantId);
+  }
+  /** Check SubCortex server health. */
+  async health() {
+    return this.http.get("/health");
+  }
+};
+function enc3(s) {
+  return encodeURIComponent(s);
+}
+
+// src/context.ts
+var CONTEXT_SCHEMA_VERSION = "1.0";
+function formatContext(user, options = {}) {
+  const format = options.format ?? "xml";
+  switch (format) {
+    case "xml":
+      return toContextXml(user, options);
+    case "json":
+      return JSON.stringify(user, null, 2);
+    case "summary":
+      return user.summary;
+  }
+}
+function toContextXml(user, options = {}) {
+  const {
+    includeMemories = true,
+    includeRelationships = true,
+    includeReminders = true,
+    includeConflicts = true,
+    includeContexts = true,
+    includeSignals = true,
+    minConfidence = 0
+  } = options;
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  const lines = [];
+  const signalsByAbout = /* @__PURE__ */ new Map();
+  const unattachedSignals = [];
+  if (includeSignals && user.signals) {
+    for (const sig of user.signals) {
+      if (sig.aboutSubject) {
+        const existing = signalsByAbout.get(sig.aboutSubject) || [];
+        existing.push(sig);
+        signalsByAbout.set(sig.aboutSubject, existing);
+      } else {
+        unattachedSignals.push(sig);
+      }
+    }
+  }
+  lines.push(`<subcortex_context version="${CONTEXT_SCHEMA_VERSION}" subject="${esc(user.subject)}" known="${user.isKnown}" ts="${ts}">`);
+  if (includeConflicts && user.conflicts.length > 0) {
+    lines.push(`  <conflicts count="${user.conflicts.length}" priority="critical">`);
+    for (const conflict of user.conflicts) {
+      lines.push(`    <conflict id="${esc(conflict.id)}">${esc(conflict.hint)}</conflict>`);
+    }
+    lines.push(`  </conflicts>`);
+  }
+  if (includeReminders && user.reminders.length > 0) {
+    lines.push(`  <reminders count="${user.reminders.length}" priority="high">`);
+    for (const reminder of user.reminders) {
+      lines.push(`    <reminder id="${esc(reminder.id)}" confidence="${fmtConf(reminder.confidence)}">${esc(String(reminder.value))}</reminder>`);
+    }
+    lines.push(`  </reminders>`);
+  }
+  if (includeContexts && user.contexts.length > 0) {
+    lines.push(`  <active_contexts count="${user.contexts.length}">`);
+    for (const ctx of user.contexts) {
+      const ctxSignals = findSignalsForFact(ctx, signalsByAbout);
+      if (ctxSignals.length > 0) {
+        lines.push(`    <context predicate="${esc(ctx.predicate)}" confidence="${fmtConf(ctx.confidence)}">`);
+        lines.push(`      ${esc(String(ctx.value))}`);
+        for (const sig of ctxSignals) {
+          lines.push(`      ${renderSignal(sig)}`);
+        }
+        lines.push(`    </context>`);
+      } else {
+        lines.push(`    <context predicate="${esc(ctx.predicate)}" confidence="${fmtConf(ctx.confidence)}">${esc(String(ctx.value))}</context>`);
+      }
+    }
+    lines.push(`  </active_contexts>`);
+  }
+  if (user.name) {
+    const trajectoryAttr = user.rapportTrajectory ? ` rapport_trajectory="${user.rapportTrajectory}"` : "";
+    lines.push(`  <identity name="${esc(String(user.name))}" subject="${esc(user.subject)}"${trajectoryAttr}>`);
+    const identityPredicates = /* @__PURE__ */ new Set(["name", "full_name", "role", "title", "department", "team", "email", "start_date", "communication_style"]);
+    const identityFacts = user.memories.filter((m) => identityPredicates.has(m.predicate) && m.confidence >= minConfidence);
+    for (const fact of identityFacts) {
+      const factSignals = findSignalsForFact(fact, signalsByAbout);
+      if (factSignals.length > 0) {
+        lines.push(`    <fact predicate="${esc(fact.predicate)}" confidence="${fmtConf(fact.confidence)}">`);
+        lines.push(`      ${esc(String(fact.value))}`);
+        for (const sig of factSignals) {
+          lines.push(`      ${renderSignal(sig)}`);
+        }
+        lines.push(`    </fact>`);
+      } else {
+        lines.push(`    <fact predicate="${esc(fact.predicate)}" confidence="${fmtConf(fact.confidence)}">${esc(String(fact.value))}</fact>`);
+      }
+    }
+    for (const sig of unattachedSignals) {
+      lines.push(`    ${renderSignal(sig)}`);
+    }
+    lines.push(`  </identity>`);
+  }
+  if (includeMemories) {
+    const identityPredicates = /* @__PURE__ */ new Set(["name", "full_name", "role", "title", "department", "team", "email", "start_date", "communication_style"]);
+    const knowledge = user.memories.filter(
+      (m) => !identityPredicates.has(m.predicate) && m.confidence >= minConfidence
+    );
+    if (knowledge.length > 0) {
+      lines.push(`  <knowledge count="${knowledge.length}">`);
+      for (const mem of knowledge) {
+        const memSignals = findSignalsForFact(mem, signalsByAbout);
+        if (memSignals.length > 0) {
+          lines.push(`    <fact predicate="${esc(mem.predicate)}" confidence="${fmtConf(mem.confidence)}">`);
+          lines.push(`      ${esc(String(mem.value))}`);
+          for (const sig of memSignals) {
+            lines.push(`      ${renderSignal(sig)}`);
+          }
+          lines.push(`    </fact>`);
+        } else {
+          lines.push(`    <fact predicate="${esc(mem.predicate)}" confidence="${fmtConf(mem.confidence)}">${esc(String(mem.value))}</fact>`);
+        }
+      }
+      lines.push(`  </knowledge>`);
+    }
+  }
+  if (includeRelationships && user.connectedPeople.length > 0) {
+    lines.push(`  <relationships count="${user.connectedPeople.length}">`);
+    for (const person of user.connectedPeople) {
+      const personSignals = signalsByAbout.get(person.subject) || [];
+      const hasContent = person.facts.length > 0 || personSignals.length > 0;
+      if (!hasContent) {
+        lines.push(`    <person name="${esc(person.name)}" relationship="${esc(person.relationship)}" />`);
+      } else {
+        lines.push(`    <person name="${esc(person.name)}" relationship="${esc(person.relationship)}">`);
+        for (const fact of person.facts) {
+          lines.push(`      <fact predicate="${esc(fact.predicate)}">${esc(String(fact.value))}</fact>`);
+        }
+        for (const sig of personSignals) {
+          lines.push(`      ${renderSignal(sig)}`);
+        }
+        lines.push(`    </person>`);
+      }
+    }
+    lines.push(`  </relationships>`);
+  }
+  lines.push(`</subcortex_context>`);
+  return lines.join("\n");
+}
+function renderSignal(sig) {
+  const aboutAttr = sig.aboutSubject ? ` about="${esc(sig.aboutSubject)}"` : "";
+  return `<signal type="${esc(sig.type)}" intensity="${fmtConf(sig.intensity)}" decayed="${fmtConf(sig.decayedIntensity)}" age_hours="${sig.ageHours}"${aboutAttr}>${esc(sig.content)}</signal>`;
+}
+function findSignalsForFact(fact, signalsByAbout) {
+  const results = [];
+  for (const [aboutSubject, signals] of signalsByAbout) {
+    if (aboutSubject.includes(fact.predicate) || aboutSubject.includes(String(fact.value).toLowerCase().replace(/\s+/g, "-").slice(0, 30))) {
+      results.push(...signals);
+    }
+  }
+  return results;
+}
+function fmtConf(n) {
+  return n.toFixed(2);
+}
+function esc(s) {
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentsNamespace,
+  AssertionsNamespace,
+  CONTEXT_SCHEMA_VERSION,
+  ConfidenceLevel,
+  ConfidenceScores,
+  EntityPredicate,
+  EntityRelationship,
+  EventPredicate,
+  IdentityPredicate,
+  IntakeNamespace,
+  MULTI_VALUE_PREDICATES,
+  MemoryNamespace,
+  MemoryPredicate,
+  NEGATIVE_SIGNALS,
+  OrgRelationship,
+  POSITIVE_SIGNALS,
+  Predicates,
+  RELATIONSHIP_LABELS,
+  REVERSE_RELATIONSHIPS,
+  RapportPredicate,
+  RelationshipTypes,
+  RelationshipsNamespace,
+  SIGNAL_DECAY_CONFIG,
+  SYSTEM_SIGNAL_TYPES,
+  SignalsNamespace,
+  SubCortexAuthenticationError,
+  SubCortexAuthorizationError,
+  SubCortexClient,
+  SubCortexConflictError,
+  SubCortexError,
+  SubCortexNetworkError,
+  SubCortexNotFoundError,
+  SubCortexRateLimitError,
+  SubCortexServerError,
+  SubCortexTimeoutError,
+  SubCortexValidationError,
+  SubjectPrefix,
+  UsersNamespace,
+  WorkPredicate,
+  confidenceToScore,
+  formatContext,
+  getDecayHalfLife,
+  isValidSignalType,
+  scoreToConfidence,
+  subject,
+  toContextXml
+});
+//# sourceMappingURL=index.cjs.map