burhan-mop 0.1.5 → 0.1.6

package/.MOP/PROTOCOL.md

@@ -60,6 +60,40 @@ Gate order:
 3. `AGENT_GATE`
 4. `ACTION`
 
+## Answer Contract
+
+For every authenticated user-facing answer, the assistant must show the active
+named agent before the content. This applies to short answers, explanations,
+status updates, plans, code-change summaries, and final responses.
+
+Required first line format:
+
+```text
+agent: <agent-name> (<agent-role>) to <user>
+```
+
+Rules:
+
+- Do not answer authenticated work without an active named agent.
+- If no active agent exists, ask the user to name the required agent and stop.
+- After `agent route`, use `answerContract.firstLine` from the JSON response.
+- Party Mode keeps the full party dialogue format, but the final handoff to the
+  user must still show the speaking agent.
+- Never hide the selected agent in prose. The first visible line must identify
+  the agent.
+
+Before answering, restore monthly memory:
+
+```bash
+node .MOP/scripts/mop-core.mjs memory brief --actor <codename>
+```
+
+After meaningful work or a useful answer, save memory:
+
+```bash
+node .MOP/scripts/mop-core.mjs memory add --actor <codename> --kind conversation --summary "<one-line outcome>"
+```
+
 ## Agent Router
 
 After authentication and before the Agent Gate, route the user's task to one
@@ -88,6 +122,9 @@ Routing rules:
   genuinely requires several areas of expertise.
 - If the route reports `partyMode.active: true`, run Party Mode before the final
   answer. Name any missing participant agents first.
+- The route JSON includes an `answerContract`. The assistant must restore
+  monthly memory, start the visible answer with `answerContract.firstLine`, and
+  save a one-line memory after meaningful work.
 
 Example:
 
@@ -282,6 +319,34 @@ The skill must call `mop-workflow.mjs help` and answer with the next action,
 lead agent, party agents, next artifact, and whether readiness/adversarial gates
 apply.
 
+## Monthly Memory
+
+MOP keeps durable memory in two layers:
+
+- `.MOP/STATE.json` ledger for compact structured state.
+- `.MOP/memory/YYYY-MM.jsonl` for append-only monthly conversation memory.
+
+The monthly memory file exists so a fresh chat can restore prior context without
+the user explaining the whole project again. Each useful session must:
+
+1. Run `memory brief` before answering after authentication.
+2. Save one-line outcomes with `memory add`.
+3. Use `.MOP/memory/SESSION_BRIEF.md` as the short human-readable handoff.
+
+Commands:
+
+```bash
+node .MOP/scripts/mop-core.mjs memory brief --actor <codename>
+node .MOP/scripts/mop-core.mjs memory restore --actor <codename>
+node .MOP/scripts/mop-core.mjs memory add --actor <codename> --kind conversation --summary "<what happened>"
+```
+
+Autosycn memory also writes to the monthly memory file:
+
+```bash
+node .MOP/scripts/mop-autosycn.mjs memory --actor <codename> --summary "<what changed>"
+```
+
 ## Installer
 
 The package installer command is:

package/.MOP/STATE.json

@@ -13,6 +13,31 @@
     "defaultTitle": "Core Agent",
     "gateOrder": "AUTH_GATE_THEN_AGENT_ROUTER_THEN_AGENT_GATE_THEN_ACTION"
   },
+  "answerPolicy": {
+    "requireVisibleAgent": true,
+    "visibleAgentFormat": "agent: <agent-name> (<agent-role>) to <user>",
+    "requireMemoryRestore": true,
+    "requireMemorySave": true,
+    "rules": [
+      "Every authenticated user-facing answer must start with the active named agent line.",
+      "If no active named agent exists, ask the user to name the required agent before answering the task.",
+      "Party Mode keeps its dialogue format, but the final handoff to the user must still show the speaking agent."
+    ]
+  },
+  "memoryPolicy": {
+    "enabled": true,
+    "directory": ".MOP/memory",
+    "sessionBrief": ".MOP/memory/SESSION_BRIEF.md",
+    "monthlyPattern": "YYYY-MM.jsonl",
+    "recentLimit": 20,
+    "restoreBeforeAnswer": true,
+    "saveAfterMeaningfulWork": true,
+    "rules": [
+      "Save one-line memories to a monthly JSONL file so new chats can restore context.",
+      "Generate SESSION_BRIEF.md from recent monthly memory entries.",
+      "Read memory brief before answering any authenticated task."
+    ]
+  },
   "agentRouter": {
     "enabled": true,
     "primaryAgentLimit": 1,

package/.MOP/scripts/mop-autosycn.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { spawnSync } from 'node:child_process';
@@ -109,6 +109,123 @@ function agentLedgerFields(agent) {
   } : {};
 }
 
+function memoryPolicy(state) {
+  return state.memoryPolicy || {
+    enabled: true,
+    directory: '.MOP/memory',
+    sessionBrief: '.MOP/memory/SESSION_BRIEF.md',
+    monthlyPattern: 'YYYY-MM.jsonl',
+    recentLimit: 20
+  };
+}
+
+function answerPolicy(state) {
+  return state.answerPolicy || {
+    requireVisibleAgent: true,
+    visibleAgentFormat: 'agent: <agent-name> (<agent-role>) to <user>'
+  };
+}
+
+function monthKey(date = new Date()) {
+  return date.toISOString().slice(0, 7);
+}
+
+function memoryDirFor(state) {
+  return join(rootDir, memoryPolicy(state).directory || '.MOP/memory');
+}
+
+function monthlyMemoryPath(state, month = monthKey()) {
+  const policy = memoryPolicy(state);
+  const filename = (policy.monthlyPattern || 'YYYY-MM.jsonl').replace('YYYY-MM', month);
+  return join(memoryDirFor(state), filename);
+}
+
+function sessionBriefPath(state) {
+  return join(rootDir, memoryPolicy(state).sessionBrief || '.MOP/memory/SESSION_BRIEF.md');
+}
+
+function readJsonl(path) {
+  if (!existsSync(path)) return [];
+  return readFileSync(path, 'utf8')
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function memoryMonths(state) {
+  const dir = memoryDirFor(state);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((name) => /^\d{4}-\d{2}\.jsonl$/.test(name))
+    .map((name) => name.replace(/\.jsonl$/, ''))
+    .sort();
+}
+
+function latestMemoryEntries(state, limit = memoryPolicy(state).recentLimit || 20) {
+  const months = memoryMonths(state);
+  const selected = months.length ? months.slice(-3) : [monthKey()];
+  return selected
+    .flatMap((month) => readJsonl(monthlyMemoryPath(state, month)))
+    .sort((a, b) => String(a.at || '').localeCompare(String(b.at || '')))
+    .slice(-limit);
+}
+
+function answerLineFor(state, actor, agent = activeAgentFor(state, actor)) {
+  if (!agent) return 'agent: <name> (<role>) to <user>';
+  return (answerPolicy(state).visibleAgentFormat || 'agent: <agent-name> (<agent-role>) to <user>')
+    .replace('<agent-name>', agent.name)
+    .replace('<agent-role>', agent.role)
+    .replace('<agent-title>', agent.title || agent.role)
+    .replace('<user>', actor || 'user');
+}
+
+function appendMonthlyMemory(state, actor, kind, summary, agent = activeAgentFor(state, actor)) {
+  if (memoryPolicy(state).enabled === false) return;
+  const entry = { at: now(), actor, ...agentLedgerFields(agent), kind, summary };
+  const monthlyPath = monthlyMemoryPath(state);
+  mkdirSync(dirname(monthlyPath), { recursive: true });
+  writeFileSync(monthlyPath, `${JSON.stringify(entry)}\n`, { encoding: 'utf8', flag: 'a' });
+  writeSessionBrief(state, actor);
+}
+
+function writeSessionBrief(state, actor) {
+  const path = sessionBriefPath(state);
+  const agent = activeAgentFor(state, actor);
+  const entries = latestMemoryEntries(state, memoryPolicy(state).recentLimit || 20);
+  const lines = [
+    '# MOP Session Brief',
+    '',
+    `Updated: ${now()}`,
+    `Actor: ${actor || state.activeMember || 'unknown'}`,
+    `Active agent: ${agent ? `${agent.name} (${agent.role})` : 'none'}`,
+    `Current month: ${monthKey()}`,
+    '',
+    '## Required Session Flow',
+    '',
+    '1. Read `.MOP/STATE.json` and follow `.MOP/PROTOCOL.md`.',
+    '2. Restore memory with `node .MOP/scripts/mop-core.mjs memory brief --actor <codename>`.',
+    '3. Run `agent route` for the user task before answering.',
+    `4. Start every authenticated answer with: \`${answerLineFor(state, actor, agent)}\``,
+    '5. Save a one-line memory after meaningful work.',
+    '',
+    '## Recent Memory',
+    '',
+    ...entries.map((entry) => {
+      const who = entry.agent ? `${entry.agent} (${entry.agentRole || 'agent'})` : entry.actor;
+      return `- ${entry.at} - ${who}: ${entry.summary}`;
+    })
+  ];
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${lines.join('\n')}\n`, 'utf8');
+}
+
 function appendLedger(state, actor, kind, summary, agent = activeAgentFor(state, actor)) {
   state.ledger ||= [];
   state.ledger.push({ at: now(), actor, ...agentLedgerFields(agent), kind, summary });
@@ -392,10 +509,11 @@ function preflight(args) {
   }, null, 2));
 }
 
-function saveMemory(actor, summary) {
+function saveMemory(actor, summary, kind = 'conversation') {
   const state = readState();
   const agent = requireActiveAgent(state, actor);
   appendLedger(state, actor, 'memory', summary, agent);
+  appendMonthlyMemory(state, actor, kind, summary, agent);
   writeState(state);
   return state;
 }
@@ -588,7 +706,8 @@ function main() {
   if (command === 'memory') {
     const actor = requireArg(args, 'actor');
     const summary = String(args.summary || args.reason || 'MOP conversation');
-    saveMemory(actor, summary);
+    const kind = String(args.kind || 'conversation');
+    saveMemory(actor, summary, kind);
     console.log(`Memory saved for ${actor}.`);
     return;
   }

package/.MOP/scripts/mop-core.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { randomBytes, scryptSync, timingSafeEqual } from 'node:crypto';
@@ -87,6 +87,103 @@ function agentLedgerFields(agent) {
   } : {};
 }
 
+function memoryPolicy(state) {
+  return state.memoryPolicy || {
+    enabled: true,
+    directory: '.MOP/memory',
+    sessionBrief: '.MOP/memory/SESSION_BRIEF.md',
+    monthlyPattern: 'YYYY-MM.jsonl',
+    recentLimit: 20
+  };
+}
+
+function answerPolicy(state) {
+  return state.answerPolicy || {
+    requireVisibleAgent: true,
+    visibleAgentFormat: 'agent: <agent-name> (<agent-role>) to <user>',
+    requireMemoryRestore: true,
+    requireMemorySave: true
+  };
+}
+
+function monthKey(date = new Date()) {
+  return date.toISOString().slice(0, 7);
+}
+
+function relativeFromRoot(path) {
+  return path.replace(rootDir, '').replace(/^[\\/]/, '').replaceAll('\\', '/');
+}
+
+function memoryDirFor(state) {
+  return join(rootDir, memoryPolicy(state).directory || '.MOP/memory');
+}
+
+function monthlyMemoryPath(state, month = monthKey()) {
+  const policy = memoryPolicy(state);
+  const filename = (policy.monthlyPattern || 'YYYY-MM.jsonl').replace('YYYY-MM', month);
+  return join(memoryDirFor(state), filename);
+}
+
+function sessionBriefPath(state) {
+  return join(rootDir, memoryPolicy(state).sessionBrief || '.MOP/memory/SESSION_BRIEF.md');
+}
+
+function readJsonl(path) {
+  if (!existsSync(path)) return [];
+  return readFileSync(path, 'utf8')
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+function memoryMonths(state) {
+  const dir = memoryDirFor(state);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((name) => /^\d{4}-\d{2}\.jsonl$/.test(name))
+    .map((name) => name.replace(/\.jsonl$/, ''))
+    .sort();
+}
+
+function latestMemoryEntries(state, limit = memoryPolicy(state).recentLimit || 20) {
+  const months = memoryMonths(state);
+  const selected = months.length ? months.slice(-3) : [monthKey()];
+  return selected
+    .flatMap((month) => readJsonl(monthlyMemoryPath(state, month)))
+    .sort((a, b) => String(a.at || '').localeCompare(String(b.at || '')))
+    .slice(-limit);
+}
+
+function answerContractFor(state, actor, agent = activeAgentFor(state, actor)) {
+  const policy = answerPolicy(state);
+  const format = policy.visibleAgentFormat || 'agent: <agent-name> (<agent-role>) to <user>';
+  const firstLine = agent
+    ? format
+      .replace('<agent-name>', agent.name)
+      .replace('<agent-role>', agent.role)
+      .replace('<agent-title>', agent.title || agent.role)
+      .replace('<user>', actor || 'user')
+    : '';
+  return {
+    required: policy.requireVisibleAgent !== false,
+    firstLine,
+    beforeAnswer: `node .MOP/scripts/mop-core.mjs memory brief --actor ${actor || '<codename>'}`,
+    afterAnswer: `node .MOP/scripts/mop-core.mjs memory add --actor ${actor || '<codename>'} --kind conversation --summary "<one-line outcome>"`,
+    rules: [
+      'Do not answer authenticated work without an active named agent.',
+      'Every user-facing answer must show the active agent line first.',
+      'Restore monthly memory before answering and save a one-line memory after meaningful work.'
+    ]
+  };
+}
+
 function requireActiveAgent(state, actor, role = 'core', title = 'Core Agent') {
   const agent = activeAgentFor(state, actor);
   if (agent) return agent;
@@ -102,6 +199,48 @@ function appendLedger(state, actor, kind, summary, agent = activeAgentFor(state,
   state.ledger.push({ at: now(), actor, ...agentLedgerFields(agent), kind, summary });
 }
 
+function appendMonthlyMemory(state, actor, kind, summary, agent = activeAgentFor(state, actor)) {
+  if (memoryPolicy(state).enabled === false) return null;
+  const entry = { at: now(), actor, ...agentLedgerFields(agent), kind, summary };
+  const monthlyPath = monthlyMemoryPath(state);
+  mkdirSync(dirname(monthlyPath), { recursive: true });
+  writeFileSync(monthlyPath, `${JSON.stringify(entry)}\n`, { encoding: 'utf8', flag: 'a' });
+  writeSessionBrief(state, actor);
+  return { entry, monthlyPath };
+}
+
+function writeSessionBrief(state, actor) {
+  const path = sessionBriefPath(state);
+  const agent = activeAgentFor(state, actor);
+  const entries = latestMemoryEntries(state, memoryPolicy(state).recentLimit || 20);
+  const contract = answerContractFor(state, actor, agent);
+  const lines = [
+    '# MOP Session Brief',
+    '',
+    `Updated: ${now()}`,
+    `Actor: ${actor || state.activeMember || 'unknown'}`,
+    `Active agent: ${agent ? `${agent.name} (${agent.role})` : 'none'}`,
+    `Current month: ${monthKey()}`,
+    '',
+    '## Required Session Flow',
+    '',
+    '1. Read `.MOP/STATE.json` and follow `.MOP/PROTOCOL.md`.',
+    '2. Authenticate if required.',
+    '3. Run `agent route` for the user task before answering.',
+    `4. Start every authenticated answer with: \`${contract.firstLine || 'agent: <name> (<role>) to <user>'}\``,
+    '5. Save a one-line memory after meaningful work.',
+    '',
+    '## Recent Memory',
+    '',
+    ...entries.map((entry) => {
+      const who = entry.agent ? `${entry.agent} (${entry.agentRole || 'agent'})` : entry.actor;
+      return `- ${entry.at} - ${who}: ${entry.summary}`;
+    })
+  ];
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${lines.join('\n')}\n`, 'utf8');
+}
+
 const routeRules = [
   {
     role: 'memory',
@@ -435,6 +574,12 @@ function login(args) {
   console.log(`Active member: ${codename}`);
   if (!activeAgentFor(state, codename) && state.agentPolicy?.requiredAfterAuth !== false) {
     console.log(`Agent diperlukan. Jalankan: node .MOP/scripts/mop-core.mjs agent activate --actor ${codename} --role ${state.agentPolicy?.defaultRole || 'core'} --title "${state.agentPolicy?.defaultTitle || 'Core Agent'}" --name "<agent-name>"`);
+  } else {
+    console.log(JSON.stringify({
+      next: 'restore-memory-and-route-task',
+      memoryRestore: `node .MOP/scripts/mop-core.mjs memory brief --actor ${codename}`,
+      answerContract: answerContractFor(state, codename)
+    }, null, 2));
   }
 }
 
@@ -553,6 +698,11 @@ function agentRoute(args) {
     route,
     partyAgents,
     activeAgent: null,
+    answerContract: null,
+    monthlyMemory: {
+      restoreCommand: `node .MOP/scripts/mop-core.mjs memory brief --actor ${actor}`,
+      saveCommand: `node .MOP/scripts/mop-core.mjs memory add --actor ${actor} --kind conversation --summary "<one-line outcome>"`
+    },
     nextAction: null
   };
 
@@ -567,6 +717,7 @@ function agentRoute(args) {
       role: agent.role,
       title: agent.title
     };
+    response.answerContract = answerContractFor(state, actor, agent);
     if (route.partyMode.active && missingPartyAgents.length) {
       response.ok = false;
       response.nextAction = 'name-required-party-agents';
@@ -596,6 +747,73 @@ function agentList() {
   }, null, 2));
 }
 
+function memoryAdd(args) {
+  const state = readState();
+  if (!state.initialized) throw new Error('MOP is not initialized.');
+  const actor = slug(requireArg(args, 'actor'));
+  if (!state.members?.[actor]) throw new Error('Unknown actor.');
+  const agent = requireActiveAgent(state, actor);
+  const summary = String(args.summary || args._?.join(' ') || '').trim();
+  const kind = String(args.kind || 'conversation');
+  if (!summary) throw new Error('Missing --summary');
+
+  appendLedger(state, actor, 'memory', summary, agent);
+  const saved = appendMonthlyMemory(state, actor, kind, summary, agent);
+  writeState(state);
+  console.log(JSON.stringify({
+    ok: true,
+    actor,
+    agent: agent.name,
+    kind,
+    summary,
+    monthlyMemory: saved ? relativeFromRoot(saved.monthlyPath) : 'disabled',
+    sessionBrief: relativeFromRoot(sessionBriefPath(state)),
+    answerContract: answerContractFor(state, actor, agent)
+  }, null, 2));
+}
+
+function memoryBrief(args) {
+  const state = readState();
+  if (!state.initialized) {
+    console.log('MOP belum di-setup. Jalankan /mop-setup.');
+    return;
+  }
+  const actor = slug(String(args.actor || state.activeMember || ''));
+  if (!actor) throw new Error('Missing --actor');
+  if (!state.members?.[actor]) throw new Error('Unknown actor.');
+  const agent = activeAgentFor(state, actor);
+  const month = String(args.month || monthKey());
+  const limit = Number(args.limit || memoryPolicy(state).recentLimit || 20);
+  const currentEntries = readJsonl(monthlyMemoryPath(state, month)).slice(-limit);
+  const recentEntries = latestMemoryEntries(state, limit);
+  if (agent) writeSessionBrief(state, actor);
+  console.log(JSON.stringify({
+    ok: true,
+    actor,
+    activeAgent: agent ? {
+      id: agent.id,
+      name: agent.name,
+      role: agent.role,
+      title: agent.title
+    } : null,
+    answerContract: answerContractFor(state, actor, agent),
+    memory: {
+      month,
+      monthPath: relativeFromRoot(monthlyMemoryPath(state, month)),
+      sessionBrief: relativeFromRoot(sessionBriefPath(state)),
+      currentMonthEntries: currentEntries,
+      recentEntries
+    },
+    next: agent
+      ? 'Use answerContract.firstLine before answering, then save memory after meaningful work.'
+      : `Agent diperlukan. Jalankan: node .MOP/scripts/mop-core.mjs agent activate --actor ${actor} --role ${state.agentPolicy?.defaultRole || 'core'} --title "${state.agentPolicy?.defaultTitle || 'Core Agent'}" --name "<agent-name>"`
+  }, null, 2));
+}
+
+function memoryRestore(args) {
+  return memoryBrief(args);
+}
+
 function memberGitIdentity(args) {
   const state = readState();
   if (!state.initialized) throw new Error('MOP is not initialized.');
@@ -621,6 +839,8 @@ function validate() {
   if (!Array.isArray(state.agentCatalog)) errors.push('agentCatalog must be array');
   if (state.activeAgents && typeof state.activeAgents !== 'object') errors.push('activeAgents must be object');
   if (state.agentPolicy && typeof state.agentPolicy !== 'object') errors.push('agentPolicy must be object');
+  if (state.answerPolicy && typeof state.answerPolicy !== 'object') errors.push('answerPolicy must be object');
+  if (state.memoryPolicy && typeof state.memoryPolicy !== 'object') errors.push('memoryPolicy must be object');
   if (state.agentRouter && typeof state.agentRouter !== 'object') errors.push('agentRouter must be object');
   if (state.partyMode && typeof state.partyMode !== 'object') errors.push('partyMode must be object');
   if (state.projectRootPolicy && typeof state.projectRootPolicy !== 'object') errors.push('projectRootPolicy must be object');
@@ -703,6 +923,8 @@ function status() {
       return [codename, agent ? { name: agent.name, role: agent.role, id: agent.id } : { id: agentId, missing: true }];
     })),
     agentPolicy: state.agentPolicy || {},
+    answerPolicy: answerPolicy(state),
+    memoryPolicy: memoryPolicy(state),
     agentRouter: state.agentRouter || {},
     partyMode: state.partyMode || {},
     workflow: {
@@ -756,6 +978,9 @@ function main() {
   if (command === 'agent' && subcommand === 'require') return agentRequire(args);
   if (command === 'agent' && subcommand === 'route') return agentRoute(args);
   if (command === 'agent' && subcommand === 'list') return agentList();
+  if (command === 'memory' && subcommand === 'add') return memoryAdd(args);
+  if (command === 'memory' && subcommand === 'brief') return memoryBrief(args);
+  if (command === 'memory' && subcommand === 'restore') return memoryRestore(args);
 
   console.log(`Usage:
   node .MOP/scripts/mop-core.mjs status
@@ -768,7 +993,10 @@ function main() {
   node .MOP/scripts/mop-core.mjs agent current --actor CODE
   node .MOP/scripts/mop-core.mjs agent require --actor CODE [--role ROLE] [--title TITLE]
   node .MOP/scripts/mop-core.mjs agent route --actor CODE --task "task text"
-  node .MOP/scripts/mop-core.mjs agent list`);
+  node .MOP/scripts/mop-core.mjs agent list
+  node .MOP/scripts/mop-core.mjs memory brief --actor CODE [--month YYYY-MM]
+  node .MOP/scripts/mop-core.mjs memory add --actor CODE --kind conversation --summary "what happened"
+  node .MOP/scripts/mop-core.mjs memory restore --actor CODE`);
 }
 
 try {

package/.agents/AGENTS.md

@@ -14,6 +14,13 @@ Before doing anything, read `.MOP/STATE.json` and follow
 - After login, run the Agent Router: every conversation and action must route
   to one primary named agent. Check with `mop-core.mjs agent route --actor
   <codename> --task "<user task>"`.
+- Before answering, restore monthly memory with
+  `mop-core.mjs memory brief --actor <codename>`.
+- Every authenticated user-facing answer must start with the routed
+  `answerContract.firstLine`, for example:
+  `agent: <agent-name> (<agent-role>) to <user>`.
+- After meaningful work, save memory with
+  `mop-core.mjs memory add --actor <codename> --kind conversation --summary "<outcome>"`.
 - If the router says clarification is needed, ask the clarifying questions
   before implementation.
 - If the router activates Party Mode, show visible agent-to-agent dialogue using

package/AGENTS.md

@@ -14,6 +14,13 @@ follow `.MOP/PROTOCOL.md`.
   It selects one primary role and may recommend any number of support roles
   when genuinely needed. If no named agent exists for a needed role, ask the
   user to name it and save it with `agent activate`.
+- Before answering an authenticated task, restore monthly memory:
+  `mop-core.mjs memory brief --actor <codename>`.
+- Every authenticated user-facing answer must start with the routed named agent
+  line from `answerContract.firstLine`, for example:
+  `agent: <agent-name> (<agent-role>) to <user>`.
+- After meaningful work or a useful answer, save memory:
+  `mop-core.mjs memory add --actor <codename> --kind conversation --summary "<one-line outcome>"`.
 
 | Role | Name | Description |
 | :--- | :--- | :--- |
@@ -49,6 +56,8 @@ different agents.
 The active named agent must be recorded on every memory/ledger action. Do not
 activate irrelevant agents; route to one primary agent first, then add support
 agents through Party Mode only when useful.
+If the assistant cannot show the active agent line, it must stop and repair the
+agent route instead of answering invisibly.
 
 Default skill: `autosycn`. After meaningful changes, use
 `.MOP/scripts/mop-autosycn.mjs`. It must commit and merge with the

package/CLAUDE.md

@@ -14,6 +14,13 @@ follow `.MOP/PROTOCOL.md`.
   It selects one primary role and may recommend any number of support roles
   when genuinely needed. If no named agent exists for a needed role, ask the
   user to name it and save it with `agent activate`.
+- Before answering an authenticated task, restore monthly memory:
+  `mop-core.mjs memory brief --actor <codename>`.
+- Every authenticated user-facing answer must start with the routed named agent
+  line from `answerContract.firstLine`, for example:
+  `agent: <agent-name> (<agent-role>) to <user>`.
+- After meaningful work or a useful answer, save memory:
+  `mop-core.mjs memory add --actor <codename> --kind conversation --summary "<one-line outcome>"`.
 - If the router marks the task as ambiguous, the named primary agent must ask
   clarifying questions before implementation.
 - If the router returns `partyMode.active: true`, use Party Mode. Show
@@ -34,6 +41,8 @@ different agents.
 The active named agent must be recorded on every memory/ledger action. Do not
 activate irrelevant agents; route to one primary agent first, then add support
 agents through Party Mode only when useful.
+If the assistant cannot show the active agent line, it must stop and repair the
+agent route instead of answering invisibly.
 
 Default skill: `autosycn`. After meaningful changes, use
 `.MOP/scripts/mop-autosycn.mjs`. It must commit and merge with the

package/GEMINI.md

@@ -9,6 +9,13 @@ rules are imported below.
 
 - First action still applies: read `.MOP/STATE.json` and follow
   `.MOP/PROTOCOL.md`.
+- After authentication, run `mop-core.mjs memory brief --actor <codename>` and
+  `mop-core.mjs agent route --actor <codename> --task "<user task>"` before
+  answering.
+- Every authenticated answer must start with `answerContract.firstLine`, for
+  example: `agent: <agent-name> (<agent-role>) to <user>`.
+- Save a one-line memory after meaningful work with
+  `mop-core.mjs memory add --actor <codename> --kind conversation --summary "<outcome>"`.
 - Treat the current workspace root as the project root; do not create a nested
   project wrapper folder for app work unless the user explicitly asks for it.
 - Use `.gemini/settings.json` for context filenames and MCP server setup.

package/README.bm.md

@@ -142,7 +142,7 @@ dan merge hanya bila workflow selamat.
 | --- | --- |
 | npm package | [`burhan-mop`](https://www.npmjs.com/package/burhan-mop) |
 | command latest | `npx burhan-mop install` |
-| GitHub release | [`v0.1.5`](https://github.com/BURHANDEV-ENTERPRISE/BURHAN-MOP/releases/tag/v0.1.5) |
+| GitHub release | [`v0.1.6`](https://github.com/BURHANDEV-ENTERPRISE/BURHAN-MOP/releases/tag/v0.1.6) |
 | Node | `>=20` |
 
 ## Links

package/README.md

@@ -141,7 +141,7 @@ and merges only when the workflow is safe.
 | --- | --- |
 | npm package | [`burhan-mop`](https://www.npmjs.com/package/burhan-mop) |
 | latest command | `npx burhan-mop install` |
-| GitHub release | [`v0.1.5`](https://github.com/BURHANDEV-ENTERPRISE/BURHAN-MOP/releases/tag/v0.1.5) |
+| GitHub release | [`v0.1.6`](https://github.com/BURHANDEV-ENTERPRISE/BURHAN-MOP/releases/tag/v0.1.6) |
 | Node | `>=20` |
 
 ## Links

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "burhan-mop",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "MOP portable agent memory core installer and CLI.",
   "type": "module",
   "author": "BURHANDEV ENTERPRISE",