@hiveku-apps/sync 0.4.0 → 0.5.0

package/src/memory-owner.mjs

@@ -0,0 +1,464 @@
+/**
+ * Who owns a memory entry, and where the Memory page shows the rows that are
+ * not an agent's own (memory surfaces audit G14 and G9).
+ *
+ * The builder is the source of truth. Its memory_list answers each entry with
+ * `owner` (a department key, or null when the entry is shared with every
+ * agent) and `placement` (where the Memory page shows it). `pull` files each
+ * entry by those fields whenever they are present. This module is the
+ * FALLBACK for a builder that does not return them yet, and it is a port of
+ * the builder's own rules, so a folder pulled from either builder lands the
+ * same way:
+ *
+ *   ownerOf          src/lib/olympus/memory-department.ts resolveOwnerDepartment,
+ *                    with the one owner rule's Marketing exception for typed
+ *                    rows (below).
+ *   accountPlacement src/components/memory/tree/tree-model.ts placeRow, for the
+ *                    `_account:*` rows (the chief of staff's own memory, and
+ *                    Voice and pronunciation under About your business).
+ *   ownedPlacement   the same placeRow for every other row, from its owner:
+ *                    which agent the page shows it under, or that the page
+ *                    hides it because no agent reads it (placeOwned).
+ *   isSystemRow      the same file's rule 7: rows the page never shows.
+ *
+ * THE ONE OWNER RULE for a typed row (`_rule:`, `_skill:`, `_command:`, `_agent:`):
+ *   (a) the `department` column, when it is set and is not 'marketing';
+ *   (b) when the column is empty or 'marketing' and the text carries a
+ *       canonical Marketing-family marker (`<!-- department: x -->`, x in the
+ *       Marketing family), that topic. These are the seeded starter rows
+ *       (column 'marketing' plus a topic marker);
+ *   (c) column 'marketing' with no family marker: the Marketing parent itself;
+ *   (d) column empty: the marker, then the front matter, then the shape of the
+ *       domain, else no owner (shared with every agent).
+ * Every other row: `_identity:*` by its slug (a canonical department), else
+ * the department its front matter declares; the rest by the column, then the
+ * marker, then the front matter, then the shape of the domain.
+ *
+ * Pure: no files, no network.
+ */
+
+/**
+ * The Marketing family: the Marketing parent and its topics. Peers, each with
+ * its own owner key (builder src/lib/olympus/memory-types.ts
+ * MARKETING_FAMILY_DEPARTMENTS). Analytics is a Marketing topic (audit
+ * decision 6).
+ */
+export const MARKETING_FAMILY = Object.freeze([
+  'marketing',
+  'content',
+  'seo',
+  'social',
+  'ppc',
+  'outbound',
+  'branding',
+  'customer_avatar',
+  'customer_journey',
+  'website_design',
+  'knowledge_base',
+  'workflow',
+  'before_after_grid',
+  'email',
+  'analytics',
+]);
+
+/** Every canonical department (memory-types.ts VALID_DEPARTMENTS). */
+export const DEPARTMENTS = Object.freeze([
+  ...MARKETING_FAMILY,
+  'sales',
+  'helpdesk',
+  'production',
+  'accounting',
+  'comms',
+  'coder',
+  'orchestrator',
+]);
+
+const DEPARTMENT_SET = new Set(DEPARTMENTS);
+const MARKETING_SET = new Set(MARKETING_FAMILY);
+
+export function isDepartment(value) {
+  return typeof value === 'string' && DEPARTMENT_SET.has(value);
+}
+
+export function isMarketingTopic(value) {
+  return typeof value === 'string' && MARKETING_SET.has(value);
+}
+
+/** Trim and lowercase, blank to null (memory-department.ts normalize). */
+function normalize(value) {
+  const v = typeof value === 'string' ? value.trim().toLowerCase() : '';
+  return v || null;
+}
+
+// ─── Reading the declarations out of the text ────────────────────────────
+
+/** The first `<!-- department: x -->` anywhere (JavaScript's \w is [A-Za-z0-9_]). */
+const MARKER_RE = /<!--\s*department:\s*(\w+)\s*-->/i;
+
+/**
+ * The one marker line parseIdentity skips above front matter
+ * (agent-identity.ts LEADING_DEPARTMENT_MARKER: ASCII whitespace, an ASCII word).
+ */
+const LEADING_MARKER_RE =
+  /^[ \t\n\r\f\v]*<!--[ \t\n\r\f\v]*department:[ \t\n\r\f\v]*[A-Za-z0-9_]+[ \t\n\r\f\v]*-->[ \t\n\r\f\v]*\n/i;
+
+/** A double-quoted front matter value, decoded the way the identity editor wrote it. */
+function decodeQuoted(inner) {
+  try {
+    const decoded = JSON.parse(`"${inner}"`);
+    return typeof decoded === 'string' ? decoded : inner;
+  } catch {
+    return inner;
+  }
+}
+
+/** The `department:` field of the front matter at the top (parseIdentity), raw, or ''. */
+function frontMatterDepartmentRaw(content) {
+  const withoutTag = String(content ?? '').replace(LEADING_MARKER_RE, '');
+  const fm = withoutTag.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
+  const header = fm?.[1] ?? '';
+  const m = header.match(/^department:\s*"((?:[^"\\\n]|\\.)*)"|^department:\s*(\S.*)$/im);
+  if (!m) return '';
+  const value = m[1] !== undefined ? decodeQuoted(m[1]) : (m[2] ?? '');
+  return value.replace(/^\s+/, '');
+}
+
+/** The first marker, when it names a canonical department. */
+function markerDepartment(content) {
+  const marker = normalize(String(content ?? '').match(MARKER_RE)?.[1]);
+  return marker && isDepartment(marker) ? marker : null;
+}
+
+/**
+ * An explicit declaration in the text (memory-department.ts
+ * departmentTagFromContent): the first marker, then the front matter's
+ * `department:`, each only when it is a canonical department. A prose line
+ * such as "department: Engineering" is not a declaration.
+ */
+export function departmentTagFromContent(content) {
+  if (!content) return null;
+  const marker = markerDepartment(content);
+  if (marker) return marker;
+  const declared = normalize(frontMatterDepartmentRaw(content));
+  return declared && isDepartment(declared) ? declared : null;
+}
+
+/** memory-types.ts deriveDepartmentFromDomain: a plain department name, or an `_identity:<dept>`. */
+export function domainShapeDepartment(domain) {
+  if (typeof domain !== 'string' || !domain) return null;
+  if (domain.startsWith('_identity:')) {
+    const dept = domain.slice('_identity:'.length).trim().toLowerCase();
+    return isDepartment(dept) ? dept : null;
+  }
+  for (const prefix of ['_skill:', '_rule:', '_command:', '_agent:', '_workspace:', '_account:']) {
+    if (domain.startsWith(prefix)) return null;
+  }
+  return isDepartment(domain) ? domain : null;
+}
+
+// ─── Kinds of row ────────────────────────────────────────────────────────
+
+const ACCOUNT_MEMORY_DOMAINS = new Set(['account', 'account-suggestions']);
+
+/** The account memory's two rows (About your business): never a department's. */
+export function isAccountMemoryRow(domain) {
+  return typeof domain === 'string' && ACCOUNT_MEMORY_DOMAINS.has(domain.trim().toLowerCase());
+}
+
+function lower(domain) {
+  return typeof domain === 'string' ? domain.trim().toLowerCase() : '';
+}
+
+/** `_account:*`: the chief of staff's own memory, and Voice and pronunciation. */
+export function isAccountScopedRow(domain) {
+  return lower(domain).startsWith('_account:');
+}
+
+const TYPE_PREFIXES = [
+  ['_skill:', 'skill'],
+  ['_rule:', 'rule'],
+  ['_command:', 'command'],
+  ['_agent:', 'agent'],
+  ['_identity:', 'identity'],
+];
+
+/**
+ * The memory type a domain holds (memory-types.ts inferType), or null for an
+ * `_<word>:` shape that is not one (internal state no page draws). A plain
+ * domain (`sales`, `seo`) is an agent's notes: type `memory`.
+ */
+export function memoryTypeOf(domain) {
+  const d = lower(domain);
+  for (const [prefix, type] of TYPE_PREFIXES) if (d.startsWith(prefix)) return type;
+  if (/^_[a-z_]+:/.test(d)) return null;
+  return 'memory';
+}
+
+/** A rule, skill, shortcut or specialist: the rows the one owner rule's Marketing exception covers. */
+export function isTypedRow(domain) {
+  const type = memoryTypeOf(domain);
+  return type === 'rule' || type === 'skill' || type === 'command' || type === 'agent';
+}
+
+// ─── The security preamble the agent servers add ─────────────────────────
+
+/** memory-sanitize.ts SECURITY_MARKER: text the agent servers inject, matched byte for byte. */
+const SECURITY_MARKER = '# Security context — read this BEFORE every action';
+const PREAMBLE_TERMINATOR_RE = /^─{4,}\s*$/m;
+const TOP_HEADING_RE = /^# /m;
+
+/** memory-sanitize.ts stripAgentPreamble. */
+function stripAgentPreamble(content) {
+  let out = content;
+  for (;;) {
+    const i = out.indexOf(SECURITY_MARKER);
+    if (i < 0) return out;
+    const rest = out.slice(i);
+    const m = rest.match(PREAMBLE_TERMINATOR_RE);
+    let end;
+    if (m) {
+      end = (m.index ?? 0) + m[0].length;
+    } else {
+      const next = rest.slice(SECURITY_MARKER.length).match(TOP_HEADING_RE);
+      end = next ? SECURITY_MARKER.length + next.index : rest.length;
+    }
+    out = (out.slice(0, i) + rest.slice(end)).replace(/^\n+/, '');
+  }
+}
+
+/** The row holds nothing but the agents' own security preamble: never an owner's memory. */
+export function isPreambleOnly(content) {
+  const text = typeof content === 'string' ? content : '';
+  return text.includes(SECURITY_MARKER) && stripAgentPreamble(text).trim() === '';
+}
+
+/** Never shown on the Memory page (tree-model.ts rule 7), so never mirrored. */
+const SYSTEM_PREFIXES = ['_workspace:', '_digest:', '_custom_field:'];
+
+/**
+ * Internal state, never an owner's memory: the system prefixes, any other
+ * `_<word>:` shape no page draws, and a row that holds nothing but the
+ * security preamble. `_account:*` rows are placed by accountPlacement instead.
+ */
+export function isSystemRow(domain, content) {
+  const d = lower(domain);
+  if (SYSTEM_PREFIXES.some((prefix) => d.startsWith(prefix))) return true;
+  if (isPreambleOnly(content)) return true;
+  if (!d.startsWith('_account:') && memoryTypeOf(d) === null) return true;
+  return false;
+}
+
+// ─── The owner ───────────────────────────────────────────────────────────
+
+/**
+ * The department that owns an entry, or null when no agent does (it is
+ * shared with every agent). `row` is a memory_list entry: `domain`,
+ * `department` (the stored column) and `content`.
+ */
+export function ownerOf(row) {
+  const domain = row?.domain;
+  const content = row?.content ?? '';
+  if (isAccountMemoryRow(domain)) return 'account';
+  const d = lower(domain);
+  if (d.startsWith('_identity:')) {
+    // The slug first (the only signal two departments cannot share), then the
+    // department the front matter declares, whatever it is.
+    const slug = d.slice('_identity:'.length).trim();
+    if (isDepartment(slug)) return slug;
+    return normalize(frontMatterDepartmentRaw(content));
+  }
+  const column = normalize(row?.department);
+  if (isTypedRow(domain)) {
+    if (column && column !== 'marketing') return column; // (a)
+    const marker = markerDepartment(content);
+    if (marker && isMarketingTopic(marker)) return marker; // (b)
+    if (column === 'marketing') return 'marketing'; // (c)
+    return departmentTagFromContent(content) ?? domainShapeDepartment(domain); // (d)
+  }
+  return column ?? departmentTagFromContent(content) ?? domainShapeDepartment(domain);
+}
+
+// ─── Where the page shows an `_account:*` row ────────────────────────────
+
+/**
+ * The five business topics the chief of staff used to keep, now in About your
+ * business, each with the heading it has there (builder
+ * src/lib/account-memory/import-draft.ts TEMPLATE_SECTIONS).
+ */
+const MOVED_TOPIC_HEADINGS = Object.freeze({
+  '_account:memory:about-this-business': 'About the business',
+  '_account:memory:team-and-roles': 'Team and roles',
+  '_account:memory:current-quarter-goals': 'Goals right now',
+  '_account:memory:active-initiatives': 'Active initiatives',
+  '_account:memory:user-preferences': 'How we like to work',
+});
+export const MOVED_TOPICS = Object.freeze(Object.keys(MOVED_TOPIC_HEADINGS));
+const MOVED_SET = new Set(MOVED_TOPICS);
+
+/** The About your business heading a moved topic went to, or null for a topic this release does not know. */
+export function movedTopicHeading(domain) {
+  return MOVED_TOPIC_HEADINGS[lower(domain)] ?? null;
+}
+
+const VOICE_DOMAINS = new Set(['_account:pronunciations', '_account:voice_settings']);
+
+function orchestrator(group) {
+  return { where: 'agent', agent: 'orchestrator', topic: null, group };
+}
+
+/**
+ * Where the Memory page shows an `_account:*` row (tree-model.ts placeRow,
+ * rules 2 and 3), in the builder's `placement` shape:
+ *   Voice and pronunciation   { where: 'business', group: 'voice' }
+ *   the chief of staff        { where: 'agent', agent: 'orchestrator', group }
+ *                             `soul` How it works, `claude` Background,
+ *                             `_skill:*`, `_rule:*`, `memory:*` (notes, or
+ *                             "Moved to About your business")
+ *   anything else             { where: 'hidden', reason }
+ */
+export function accountPlacement(domain, content) {
+  const d = lower(domain);
+  if (isPreambleOnly(content)) return { where: 'hidden', reason: 'system' };
+  if (VOICE_DOMAINS.has(d)) return { where: 'business', group: 'voice' };
+  if (d === '_account:soul') return orchestrator('how-it-works');
+  if (d === '_account:claude') return orchestrator('background');
+  if (d.startsWith('_account:_skill:')) return orchestrator('skills');
+  if (d.startsWith('_account:_rule:')) return orchestrator('rules');
+  if (d.startsWith('_account:memory:')) return orchestrator(MOVED_SET.has(d) ? 'moved' : 'notes');
+  return { where: 'hidden', reason: 'legacy' };
+}
+
+// ─── Where the page shows every other row ────────────────────────────────
+
+/** The team the Memory page lists (builder tree/team-keys.ts TEAM_AGENTS). */
+export const TEAM_AGENTS = Object.freeze(['orchestrator', 'sales', 'helpdesk', 'marketing', 'production', 'accounting', 'coder', 'comms']);
+const TEAM_SET = new Set(TEAM_AGENTS);
+
+/**
+ * The departments whose own notes are ONE plain domain, their own name
+ * (tree-model.ts ONE_NOTES_NAME_DEPARTMENTS): their agents read that one
+ * document (the sales server reads `domain = 'sales'`), so a note one of them
+ * owns under another plain name is one its agent never reads.
+ */
+const ONE_NOTES_NAME_DEPARTMENTS = new Set(['sales', 'helpdesk', 'comms', 'production', 'accounting', 'coder']);
+
+/** The page's group for each type of row (tree-model.ts KIND_GROUP). */
+const TYPE_GROUP = Object.freeze({
+  rule: 'rules',
+  skill: 'skills',
+  command: 'shortcuts',
+  agent: 'specialists',
+  identity: 'profile',
+  memory: 'notes',
+});
+
+/** The Marketing topic whose profile and notes are documents about customers (team-keys.ts IDEAL_CUSTOMERS_TOPIC). */
+const IDEAL_CUSTOMERS_TOPIC = 'customer_avatar';
+
+/**
+ * Where the Memory page shows a row that is neither `_account:*` nor internal,
+ * given its owner (the builder's `owner`, or ownerOf): tree-model.ts placeRow
+ * rules 4 to 6 and placeOwned, in memory_list's `placement` shape.
+ *   no owner                        { where: 'shared', group }
+ *   a note a department in ONE_NOTES_NAME_DEPARTMENTS owns under a plain name
+ *   other than its own (`pipeline-notes`, column sales), or any row but a
+ *   profile the chief of staff owns outside her `_account:*` rows
+ *                                   { where: 'hidden', reason: 'unlisted' }
+ *   a team agent                    { where: 'agent', agent, topic: null, group }
+ *   a Marketing topic               { where: 'agent', agent: 'marketing', topic, group }
+ *   an owner that is no agent or topic (`mini`, `graphic_design`)
+ *                                   { where: 'hidden', reason: 'no-agent' }
+ * A hidden row is one no agent reads: the chief of staff reads only her
+ * `_account:*` rows and profiles, and the builder's follow rule
+ * (memory-department.ts followersOfOwner) gives an orchestrator or no-agent
+ * owner no followers.
+ */
+export function ownedPlacement(domain, owner) {
+  const type = memoryTypeOf(domain) ?? 'memory';
+  const group = TYPE_GROUP[type];
+  if (owner === null || owner === undefined || owner === '') return { where: 'shared', group };
+  // The page compares the stored name exactly, as the agents' own reads do.
+  if (type === 'memory' && ONE_NOTES_NAME_DEPARTMENTS.has(owner) && domain !== owner) return { where: 'hidden', reason: 'unlisted' };
+  if (owner === 'orchestrator' && type !== 'identity') return { where: 'hidden', reason: 'unlisted' };
+  if (TEAM_SET.has(owner) && owner !== 'marketing') return { where: 'agent', agent: owner, topic: null, group };
+  if (isMarketingTopic(owner)) {
+    const aboutCustomers = owner === IDEAL_CUSTOMERS_TOPIC && (type === 'identity' || type === 'memory');
+    return { where: 'agent', agent: 'marketing', topic: owner, group: aboutCustomers ? 'ideal-customers' : group };
+  }
+  return { where: 'hidden', reason: 'no-agent' };
+}
+
+// ─── The page's names ────────────────────────────────────────────────────
+
+/** The page's job names for the team (builder memory-categories.ts AGENT_JOBS). */
+const AGENT_JOBS = Object.freeze({
+  orchestrator: 'Chief of staff',
+  sales: 'Sales',
+  helpdesk: 'Support',
+  marketing: 'Marketing',
+  production: 'Production',
+  accounting: 'Accounting',
+  coder: 'Website',
+  comms: 'Communications',
+});
+
+/** The Marketing team's topics in owner words (memory-categories.ts MARKETING_TOPIC_NAMES). */
+const TOPIC_NAMES = Object.freeze({
+  marketing: 'Marketing strategy',
+  seo: 'SEO',
+  content: 'Content',
+  social: 'Social',
+  ppc: 'Paid ads',
+  email: 'Email',
+  branding: 'Branding',
+  customer_journey: 'Customer journey',
+  knowledge_base: 'Knowledge base',
+  outbound: 'Outbound',
+  workflow: 'Workflow',
+  before_after_grid: 'Before and after',
+  website_design: 'Website design',
+  customer_avatar: 'Ideal customers',
+  analytics: 'Analytics',
+});
+
+/** The owner key `pull` files an entry with no owner under. */
+export const SHARED_OWNER = 'shared';
+
+/** "Sales", "Marketing team > SEO", "Shared with every agent", or the key itself for one the page does not know. */
+export function ownerLabel(owner) {
+  if (!owner || owner === SHARED_OWNER) return 'Shared with every agent';
+  if (TOPIC_NAMES[owner]) return `Marketing team > ${TOPIC_NAMES[owner]}`;
+  return AGENT_JOBS[owner] ?? owner;
+}
+
+/** The order the page lists the team in: shared first, then the team, the Marketing topics after Marketing. */
+export function ownerOrder(owner) {
+  if (!owner || owner === SHARED_OWNER) return 0;
+  const team = ['orchestrator', 'sales', 'helpdesk'];
+  if (team.includes(owner)) return 1 + team.indexOf(owner);
+  if (MARKETING_SET.has(owner)) return 10 + MARKETING_FAMILY.indexOf(owner);
+  const rest = ['production', 'accounting', 'coder', 'comms'];
+  if (rest.includes(owner)) return 40 + rest.indexOf(owner);
+  return 100;
+}
+
+const GROUP_WORDS = Object.freeze({
+  profile: 'Profile',
+  'how-it-works': 'How it works',
+  background: 'Background',
+  rules: 'Rules',
+  skills: 'Skills',
+  notes: 'Notes',
+  moved: 'Moved to About your business',
+  'ideal-customers': 'Ideal customers',
+  shortcuts: 'Shortcuts',
+  specialists: 'Specialists',
+  voice: 'Voice and pronunciation',
+});
+
+/** The page's label for an `_account:*` placement ("Chief of staff > How it works"). */
+export function accountPlacementLabel(placement) {
+  if (placement?.where === 'business') return `About your business > ${GROUP_WORDS[placement.group] ?? placement.group}`;
+  if (placement?.where === 'agent') return `${ownerLabel(placement.agent)} > ${GROUP_WORDS[placement.group] ?? placement.group}`;
+  return 'Not shown on the Memory page';
+}