burhan-mop 0.1.5 → 0.1.7

package/.MOP/PROTOCOL.md

@@ -31,7 +31,8 @@ Use this order:
 7. Coding/adventure language.
 8. GitHub project link. Required for `team`, optional for `solo`.
 9. GitHub username.
-10. Git commit email. Use a GitHub-verified email or GitHub noreply email.
+10. Git commit email. Default to `github-noreply` so MOP derives the active
+    GitHub account email as `ID+USERNAME@users.noreply.github.com`.
 11. If `team`, ask join mode: `open`, `owner-approved`, or `invite`.
 12. Ask auto deploy: `Nak aktifkan auto deploy sekarang? Pilih provider:
     GitHub, Docker, Vercel.` If the user says later/no, answer with the defer
@@ -40,7 +41,7 @@ Use this order:
 After confirmation, run:
 
 ```bash
-node .MOP/scripts/mop-core.mjs setup --project-name "<name>" --name "<display>" --codename <codename> --password "<password>" --mode <solo|team> --conversation-language "<lang>" --coding-language "<lang>" --git-email "<github-verified-email>" [--git-name "<display>"] [--github-username "<github-login>"] [--github-url "<url>"] [--join-mode <mode>]
+node .MOP/scripts/mop-core.mjs setup --project-name "<name>" --name "<display>" --codename <codename> --password "<password>" --mode <solo|team> --conversation-language "<lang>" --coding-language "<lang>" --git-email github-noreply [--git-name "<display>"] [--github-username "<github-login>"] [--github-url "<url>"] [--join-mode <mode>]
 ```
 
 ## Agent Naming Ceremony
@@ -60,6 +61,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 +123,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 +320,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:
@@ -366,10 +432,13 @@ In team mode, an agent name is the identity.
 Autosycn is always available and should be used after meaningful state or file
 changes. It is intentionally identity-safe.
 
-Before first push for a member, configure the real Git identity:
+Before first push for a member, configure the real GitHub identity. Default to
+GitHub noreply so commits attach to the active user account without exposing
+private email:
 
 ```bash
-node .MOP/scripts/mop-core.mjs member git-identity --actor <codename> --name "<display name>" --email "<github-verified-email>" --github-username "<github-login>"
+gh auth login
+node .MOP/scripts/mop-core.mjs member git-identity --actor <codename> --name "<display name>" --email github-noreply --github-username "<github-login>"
 ```
 
 Then run:
@@ -390,6 +459,13 @@ Autosycn must:
 - Commit with `GIT_AUTHOR_NAME`, `GIT_AUTHOR_EMAIL`, `GIT_COMMITTER_NAME`, and
   `GIT_COMMITTER_EMAIL` set from member state.
 - Set local `git config user.name` and `user.email` before commit/merge.
+- For member commits, derive `user.email` from the active GitHub CLI account as
+  `ID+USERNAME@users.noreply.github.com` when
+  `autosync.githubIdentity.useNoreplyForMemberCommits` is enabled.
+- Refuse to commit or push if `gh api user` is authenticated as a different
+  GitHub username than the active member's configured `githubUsername`.
+- Use the member GitHub identity for setup, preflight, memory, and work branch
+  commits. Use `BURHAN-MOP` only for merge guardian commits.
 - In team mode, `main` is the trunk and each user works on `dev/<codename>`.
 - Push to `dev/<codename>` in team mode and `main` in solo mode.
 - After a team push, BURHAN-MOP reviews `dev/<codename>` and merges it into
@@ -404,10 +480,11 @@ Autosycn must:
 - If `githubUsername` is configured, refuse to push unless `gh api user`
   verifies the same account.
 
-Important: GitHub commit attribution comes from commit email. GitHub push actor
-comes from the credential or SSH key used by `git push`; no script can fake that.
-If GitHub shows the AI/bot as pusher, fix `gh auth login`, Git Credential
-Manager, or the SSH key account.
+Important: GitHub commit attribution comes from commit email. MOP uses the
+active GitHub account noreply email for member commits by default. GitHub push
+actor comes from the credential or SSH key used by `git push`; no script can
+fake that. If GitHub shows the wrong pusher, fix `gh auth login`, Git
+Credential Manager, or the SSH key account.
 
 ## Default Skill: auto-deploy
 

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,
@@ -374,7 +399,18 @@
       }
     },
     "requireUserGitEmail": true,
-    "verifyGhUserWhenConfigured": true
+    "verifyGhUserWhenConfigured": true,
+    "githubIdentity": {
+      "requireMatchedGhUser": true,
+      "useNoreplyForMemberCommits": true,
+      "noreplyFormat": "id-plus-login",
+      "rules": [
+        "Member commits must use the active member GitHub account, not an AI or guardian identity.",
+        "When gh is authenticated, derive member commit email as ID+USERNAME@users.noreply.github.com.",
+        "Refuse autosycn if the active gh account does not match the member githubUsername.",
+        "BURHAN-MOP identity is reserved for merge guardian commits only."
+      ]
+    }
   },
   "members": {},
   "installedSkills": [

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 });
@@ -130,22 +247,59 @@ function getMember(state, actor) {
   return member;
 }
 
+function githubIdentityPolicy(state) {
+  return state.autosync?.githubIdentity || {
+    requireMatchedGhUser: true,
+    useNoreplyForMemberCommits: true,
+    noreplyFormat: 'id-plus-login'
+  };
+}
+
+function currentGhUser() {
+  const result = runOptional('gh', ['api', 'user', '--jq', '{login:.login,id:.id,email:.email}']);
+  if (!result.ok) return null;
+  try {
+    return JSON.parse(result.stdout || '{}');
+  } catch {
+    return null;
+  }
+}
+
+function githubNoreplyEmail(user) {
+  if (!user?.login || !user?.id) return '';
+  return `${user.id}+${user.login}@users.noreply.github.com`;
+}
+
 function identityFor(state, actor) {
   const member = getMember(state, actor);
   const identity = member.gitIdentity || {};
+  const policy = githubIdentityPolicy(state);
+  const gh = currentGhUser();
   const name = identity.name || member.displayName || actor;
-  const email = identity.email || member.github?.noreplyEmail || '';
+  const githubUsername = identity.githubUsername || member.github?.username || gh?.login || '';
+  if (gh?.login && githubUsername && policy.requireMatchedGhUser !== false && gh.login.toLowerCase() !== githubUsername.toLowerCase()) {
+    throw new Error(`GitHub CLI authenticated as ${gh.login}, expected ${githubUsername}. Refusing to commit or push as the wrong user.`);
+  }
+  let email = identity.email || member.github?.noreplyEmail || '';
+  if (policy.useNoreplyForMemberCommits !== false) {
+    email = githubNoreplyEmail(gh);
+    if (!email) {
+      throw new Error('GitHub noreply identity is required for member commits. Run gh auth login as the real user, or set autosync.githubIdentity.useNoreplyForMemberCommits=false.');
+    }
+  }
   if (!email && state.autosync?.requireUserGitEmail !== false) {
     throw new Error([
       `Missing git email for ${actor}.`,
-      'Set a GitHub-verified email or noreply email first:',
-      `node .MOP/scripts/mop-core.mjs member git-identity --actor ${actor} --name "${name}" --email "<github-verified-email>" [--github-username "<username>"]`
+      'Set a GitHub-verified email or let MOP derive GitHub noreply from gh:',
+      `node .MOP/scripts/mop-core.mjs member git-identity --actor ${actor} --name "${name}" --email github-noreply [--github-username "<username>"]`
     ].join(' '));
   }
   return {
     name,
     email,
-    githubUsername: identity.githubUsername || member.github?.username || ''
+    githubUsername,
+    githubUserId: gh?.login?.toLowerCase() === githubUsername.toLowerCase() ? gh.id : identity.githubUserId,
+    emailSource: policy.useNoreplyForMemberCommits !== false ? 'github-noreply' : (identity.emailSource || 'manual')
   };
 }
 
@@ -218,15 +372,16 @@ function configureRemote(url, replaceRemote = false) {
 }
 
 function verifyGhUser(identity, state) {
-  if (!identity.githubUsername || state.autosync?.verifyGhUserWhenConfigured === false) return 'skipped';
-  const gh = runOptional('gh', ['api', 'user', '--jq', '.login']);
-  if (!gh.ok) {
+  const policy = githubIdentityPolicy(state);
+  if (state.autosync?.verifyGhUserWhenConfigured === false && policy.requireMatchedGhUser === false) return 'skipped';
+  const gh = currentGhUser();
+  if (!gh?.login) {
     throw new Error('GitHub username is configured, but gh could not verify the active account. Run gh auth login as the real user or set autosync.verifyGhUserWhenConfigured=false for SSH-only workflows.');
   }
-  if (gh.stdout.toLowerCase() !== identity.githubUsername.toLowerCase()) {
-    throw new Error(`GitHub CLI authenticated as ${gh.stdout}, expected ${identity.githubUsername}. Refusing to push as the wrong account.`);
+  if (identity.githubUsername && gh.login.toLowerCase() !== identity.githubUsername.toLowerCase()) {
+    throw new Error(`GitHub CLI authenticated as ${gh.login}, expected ${identity.githubUsername}. Refusing to push as the wrong account.`);
   }
-  return `verified:${gh.stdout}`;
+  return `verified:${gh.login}:${githubNoreplyEmail(gh) || 'email-unavailable'}`;
 }
 
 function runProjectCommand(command, env) {
@@ -392,10 +547,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;
 }
@@ -559,6 +715,7 @@ function status() {
     workBranchPrefix: state.autosync?.workBranchPrefix || 'dev',
     autoMergeToMain: state.autosync?.autoMergeToMain !== false,
     mergeGuardian: guardianConfig(state),
+    githubIdentity: githubIdentityPolicy(state),
     preflightBeforeWork: state.autosync?.preflightBeforeWork !== false,
     requireUserGitEmail: state.autosync?.requireUserGitEmail !== false,
     initialized: state.initialized,
@@ -573,7 +730,8 @@ function status() {
         displayName: member.displayName,
         gitIdentityConfigured: Boolean(member.gitIdentity?.email || member.github?.noreplyEmail),
         gitName: member.gitIdentity?.name || member.displayName || key,
-        gitEmail: member.gitIdentity?.email || member.github?.noreplyEmail || ''
+        gitEmail: member.gitIdentity?.email || member.github?.noreplyEmail || '',
+        githubUsername: member.gitIdentity?.githubUsername || member.github?.username || ''
       }
     ]))
   }, null, 2));
@@ -588,7 +746,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,8 +1,9 @@
 #!/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';
+import { spawnSync } from 'node:child_process';
 
 const here = dirname(fileURLToPath(import.meta.url));
 const coreDir = resolve(here, '..');
@@ -71,6 +72,53 @@ function verifyPassword(password, salt, expectedHex) {
   return expected.length === actual.length && timingSafeEqual(actual, expected);
 }
 
+function currentGhUser() {
+  const result = spawnSync('gh', ['api', 'user', '--jq', '{login:.login,id:.id,email:.email}'], {
+    cwd: rootDir,
+    encoding: 'utf8'
+  });
+  if (result.status !== 0) return null;
+  try {
+    return JSON.parse(result.stdout || '{}');
+  } catch {
+    return null;
+  }
+}
+
+function githubNoreplyEmail(user) {
+  if (!user?.login || !user?.id) return '';
+  return `${user.id}+${user.login}@users.noreply.github.com`;
+}
+
+function resolveGitIdentityInput(state, actor, name, emailInput, githubUsernameInput) {
+  const policy = state.autosync?.githubIdentity || {};
+  const preferNoreply = policy.useNoreplyForMemberCommits !== false;
+  const gh = currentGhUser();
+  const githubUsername = githubUsernameInput || gh?.login || '';
+  if (gh?.login && githubUsername && policy.requireMatchedGhUser !== false && gh.login.toLowerCase() !== githubUsername.toLowerCase()) {
+    throw new Error(`GitHub CLI authenticated as ${gh.login}, expected ${githubUsername}. Run gh auth login as the real user.`);
+  }
+
+  let email = String(emailInput || '').trim();
+  const wantsNoreply = !email || ['auto', 'github', 'github-noreply', 'noreply'].includes(email.toLowerCase());
+  if (preferNoreply && wantsNoreply) {
+    email = githubNoreplyEmail(gh);
+    if (!email) {
+      throw new Error('Cannot derive GitHub noreply email. Run gh auth login or provide --git-email "<github-verified-email>".');
+    }
+  }
+  if (!email && state.autosync?.requireUserGitEmail !== false) {
+    throw new Error('Git email is required. Use --git-email github-noreply after gh auth login, or provide a GitHub-verified email.');
+  }
+  return {
+    name,
+    email,
+    githubUsername,
+    githubUserId: gh?.login?.toLowerCase() === githubUsername.toLowerCase() ? gh.id : undefined,
+    emailSource: wantsNoreply && email ? 'github-noreply' : 'manual'
+  };
+}
+
 function activeAgentFor(state, actor) {
   const activeId = state.activeAgents?.[actor];
   if (!activeId) return null;
@@ -87,6 +135,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 +247,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',
@@ -363,7 +550,7 @@ function setup(args) {
   const codingLanguage = String(args['coding-language'] || 'English');
   const githubUrl = String(args['github-url'] || '');
   const gitName = String(args['git-name'] || displayName);
-  const gitEmail = String(args['git-email'] || '');
+  const gitEmail = String(args['git-email'] || 'github-noreply');
   const githubUsername = String(args['github-username'] || '');
   const joinMode = String(args['join-mode'] || 'owner-approved');
 
@@ -371,12 +558,10 @@ function setup(args) {
   if (password.length < 8) throw new Error('Password must be at least 8 characters.');
   if (!['solo', 'team'].includes(mode)) throw new Error('Mode must be solo or team.');
   if (mode === 'team' && !githubUrl) throw new Error('Team mode requires --github-url.');
-  if (state.autosync?.requireUserGitEmail !== false && !gitEmail) {
-    throw new Error('Git email is required so commits are attributed to the real user, not the AI tool.');
-  }
   if (!['open', 'owner-approved', 'invite'].includes(joinMode)) {
     throw new Error('Join mode must be open, owner-approved, or invite.');
   }
+  const gitIdentity = resolveGitIdentityInput(state, codename, gitName, gitEmail, githubUsername);
 
   const { passwordHash, passwordSalt } = hashPassword(password);
   state.initialized = true;
@@ -406,11 +591,7 @@ function setup(args) {
         conversation: conversationLanguage,
         coding: codingLanguage
       },
-      gitIdentity: {
-        name: gitName,
-        email: gitEmail,
-        githubUsername
-      },
+      gitIdentity,
       joinedAt: now()
     }
   };
@@ -435,6 +616,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 +740,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 +759,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 +789,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.');
@@ -604,12 +864,12 @@ function memberGitIdentity(args) {
   if (!member) throw new Error('Unknown actor.');
   const agent = requireActiveAgent(state, actor);
   const name = String(args.name || member.displayName || actor);
-  const email = requireArg(args, 'email');
+  const email = String(args.email || 'github-noreply');
   const githubUsername = String(args['github-username'] || member.gitIdentity?.githubUsername || '');
-  member.gitIdentity = { name, email, githubUsername };
+  member.gitIdentity = resolveGitIdentityInput(state, actor, name, email, githubUsername);
   appendLedger(state, actor, 'git-identity', `Updated git identity for ${actor}.`, agent);
   writeState(state);
-  console.log(`Git identity set for ${actor}: ${name} <${email}>${githubUsername ? ` github=${githubUsername}` : ''}`);
+  console.log(`Git identity set for ${actor}: ${member.gitIdentity.name} <${member.gitIdentity.email}>${member.gitIdentity.githubUsername ? ` github=${member.gitIdentity.githubUsername}` : ''}`);
 }
 
 function validate() {
@@ -621,8 +881,13 @@ 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.autosync?.githubIdentity && typeof state.autosync.githubIdentity !== 'object') {
+    errors.push('autosync.githubIdentity must be object');
+  }
   if (state.projectRootPolicy && typeof state.projectRootPolicy !== 'object') errors.push('projectRootPolicy must be object');
   if (state.projectRootPolicy?.rules && !Array.isArray(state.projectRootPolicy.rules)) {
     errors.push('projectRootPolicy.rules must be array');
@@ -703,6 +968,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,19 +1023,25 @@ 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
   node .MOP/scripts/mop-core.mjs validate
-  node .MOP/scripts/mop-core.mjs setup --project-name NAME --name DISPLAY --codename CODE --password PASS --mode solo|team --conversation-language LANG --coding-language LANG --git-email EMAIL [--git-name NAME] [--github-username USER] [--github-url URL]
+  node .MOP/scripts/mop-core.mjs setup --project-name NAME --name DISPLAY --codename CODE --password PASS --mode solo|team --conversation-language LANG --coding-language LANG [--git-email github-noreply|EMAIL] [--git-name NAME] [--github-username USER] [--github-url URL]
   node .MOP/scripts/mop-core.mjs login --codename CODE --password PASS
-  node .MOP/scripts/mop-core.mjs member git-identity --actor CODE --name NAME --email EMAIL [--github-username USER]
+  node .MOP/scripts/mop-core.mjs member git-identity --actor CODE --name NAME [--email github-noreply|EMAIL] [--github-username USER]
   node .MOP/scripts/mop-core.mjs agent activate --actor CODE --role ROLE --title TITLE --name NAME
   node .MOP/scripts/mop-core.mjs agent use --actor CODE --name NAME
   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
@@ -27,6 +34,10 @@ Before doing anything, read `.MOP/STATE.json` and follow
 - For risky changes, run adversarial review before implementation or merge.
 - When a role agent first appears, ask the user to name it before using it as a
   personal agent.
+- Autosycn member commits must use the active member GitHub account. By default,
+  MOP derives `ID+USERNAME@users.noreply.github.com` from `gh api user` and
+  refuses mismatched GitHub accounts. `BURHAN-MOP` identity is reserved for
+  merge guardian commits only.
 
 ## Operating Rules
 

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 |
 | :--- | :--- | :--- |
@@ -39,8 +46,8 @@ follow `.MOP/PROTOCOL.md`.
 
 For `/mop-setup`, ask in order: project name (default folder name), owner display
 name, owner codename, password, solo/team, conversation language, coding
-language, GitHub link, GitHub username, Git commit email, join mode if team,
-then whether to activate auto-deploy now or later.
+language, GitHub link, GitHub username, Git commit email (`github-noreply` by
+default), join mode if team, then whether to activate auto-deploy now or later.
 
 Agent role/template names are not personal AI names. When a role agent is first
 needed, ask the user to name it and save it with `mop-core.mjs agent activate`.
@@ -49,10 +56,15 @@ 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
 real member Git identity from state, never with the AI tool identity.
+Member commits must use the active member GitHub account; by default MOP derives
+`ID+USERNAME@users.noreply.github.com` from `gh api user` and refuses mismatched
+GitHub accounts. `BURHAN-MOP` identity is only for merge guardian commits.
 In team mode, run `preflight --actor <codename>` before starting work; work goes
 to `dev/<codename>`. Every small or large change is pushed there first, then
 BURHAN-MOP reviews and merges to `main` only when checks pass.

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,10 +41,15 @@ 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
 real member Git identity from state, never with the AI tool identity.
+Member commits must use the active member GitHub account; by default MOP derives
+`ID+USERNAME@users.noreply.github.com` from `gh api user` and refuses mismatched
+GitHub accounts. `BURHAN-MOP` identity is only for merge guardian commits.
 In team mode, run `preflight --actor <codename>` before starting work; work goes
 to `dev/<codename>`. Every small or large change is pushed there first, then
 BURHAN-MOP reviews and merges to `main` only when checks pass.

package/GEMINI.md

@@ -9,6 +9,16 @@ 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>"`.
+- Autosycn member commits must use the active member GitHub account. MOP derives
+  `ID+USERNAME@users.noreply.github.com` from `gh api user` by default and
+  refuses mismatched GitHub accounts.
 - 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.7`](https://github.com/BURHANDEV-ENTERPRISE/BURHAN-MOP/releases/tag/v0.1.7) |
 | 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.7`](https://github.com/BURHANDEV-ENTERPRISE/BURHAN-MOP/releases/tag/v0.1.7) |
 | Node | `>=20` |
 
 ## Links

package/package.json

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