@kevin0181/memoc 1.1.3 → 1.1.10

package/bin/cli.js

@@ -172,6 +172,7 @@ function scanProject(dir, depth = 0) {
 // ═══════════════════════════════════════════════════════════════════
 
 function nowISO() { return new Date().toISOString().slice(0, 19); }
+function todayISO() { return new Date().toISOString().slice(0, 10); }
 
 function stackStr(stack) { return stack.length ? stack.join(', ') : 'Not detected'; }
 
@@ -208,16 +209,145 @@ function write(filePath, content) {
   fs.writeFileSync(filePath, content, 'utf8');
 }
 
-function tplMemocCmdWrapper(cliPath = runtimeCliPath()) {
-  return `@echo off\r\nnode "${escapeCmdPath(cliPath)}" %*\r\n`;
+function slugify(value, fallback = 'note') {
+  const slug = String(value || '')
+    .toLowerCase()
+    .replace(/['"]/g, '')
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 80);
+  return slug || fallback;
 }
 
-function tplMemocPs1Wrapper(cliPath = runtimeCliPath()) {
-  return `& node ${psSingleQuote(cliPath)} @args\nexit $LASTEXITCODE\n`;
+function uniquePath(filePath) {
+  if (!fs.existsSync(filePath)) return filePath;
+  const ext = path.extname(filePath);
+  const base = filePath.slice(0, filePath.length - ext.length);
+  let i = 2;
+  while (fs.existsSync(`${base}-${i}${ext}`)) i += 1;
+  return `${base}-${i}${ext}`;
 }
 
-function tplMemocShWrapper(cliPath = runtimeCliPath()) {
-  return `#!/bin/sh\nexec node ${shellSingleQuote(cliPath)} "$@"\n`;
+function markdownTitle(src, fallback) {
+  const m = String(src || '').match(/^#\s+(.+)$/m);
+  return m ? m[1].trim() : fallback;
+}
+
+function execGitConfig(dir, key) {
+  try {
+    return require('child_process')
+      .execFileSync('git', ['config', '--get', key], { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+      .trim();
+  } catch {
+    return '';
+  }
+}
+
+function actorFile(dir) {
+  return path.join(dir, '.memoc', 'local', 'actor');
+}
+
+function sanitizeActor(value) {
+  return slugify(String(value || '').replace(/@.*$/, ''), 'unknown');
+}
+
+function detectActor(dir) {
+  if (process.env.MEMOC_ACTOR) return { actor: sanitizeActor(process.env.MEMOC_ACTOR), source: 'MEMOC_ACTOR' };
+  const localPath = actorFile(dir);
+  try {
+    const local = fs.readFileSync(localPath, 'utf8').trim();
+    if (local) return { actor: sanitizeActor(local), source: '.memoc/local/actor' };
+  } catch {}
+  const gitUser = execGitConfig(dir, 'user.name');
+  if (gitUser) return { actor: sanitizeActor(gitUser), source: 'git config user.name' };
+  const gitEmail = execGitConfig(dir, 'user.email');
+  if (gitEmail) return { actor: sanitizeActor(gitEmail), source: 'git config user.email' };
+  const osUser = process.env.USER || process.env.USERNAME || process.env.LOGNAME;
+  if (osUser) return { actor: sanitizeActor(osUser), source: 'OS user' };
+  return { actor: 'unknown', source: 'fallback' };
+}
+
+function gitBranch(dir) {
+  try {
+    return require('child_process')
+      .execFileSync('git', ['branch', '--show-current'], { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+      .trim() || 'unknown';
+  } catch {
+    return 'unknown';
+  }
+}
+
+function gitStatusFiles(dir) {
+  try {
+    const out = require('child_process')
+      .execFileSync('git', ['status', '--short'], { cwd: dir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+      .trim();
+    if (!out) return [];
+    return out.split(/\r?\n/)
+      .map(line => line.slice(3).trim())
+      .filter(Boolean)
+      .filter(file => !file.startsWith('.memoc/worklog/') && !file.startsWith('.memoc/activity.md'))
+      .slice(0, 12);
+  } catch {
+    return [];
+  }
+}
+
+function tplMemocCmdWrapper() {
+  return [
+    '@echo off',
+    'set "MEMOC_RUNTIME=%MEMOC_RUNTIME_DIR%"',
+    'if "%MEMOC_RUNTIME%"=="" (',
+    '  if not "%LOCALAPPDATA%"=="" (',
+    '    set "MEMOC_RUNTIME=%LOCALAPPDATA%\\memoc\\runtime"',
+    '  ) else (',
+    '    set "MEMOC_RUNTIME=%USERPROFILE%\\AppData\\Local\\memoc\\runtime"',
+    '  )',
+    ')',
+    'set "MEMOC_CLI=%MEMOC_RUNTIME%\\bin\\cli.js"',
+    'if exist "%MEMOC_CLI%" (',
+    '  node "%MEMOC_CLI%" %*',
+    ') else (',
+    '  npx @kevin0181/memoc@latest %*',
+    ')',
+    'exit /b %ERRORLEVEL%',
+    '',
+  ].join('\r\n');
+}
+
+function tplMemocPs1Wrapper() {
+  return [
+    '$runtime = $env:MEMOC_RUNTIME_DIR',
+    'if (-not $runtime) {',
+    '  if ($env:LOCALAPPDATA) { $runtime = Join-Path $env:LOCALAPPDATA "memoc\\runtime" }',
+    '  else { $runtime = Join-Path $env:USERPROFILE "AppData\\Local\\memoc\\runtime" }',
+    '}',
+    '$cli = Join-Path $runtime "bin\\cli.js"',
+    'if (Test-Path $cli) {',
+    '  & node $cli @args',
+    '} else {',
+    '  & npx @kevin0181/memoc@latest @args',
+    '}',
+    'exit $LASTEXITCODE',
+    '',
+  ].join('\n');
+}
+
+function tplMemocShWrapper() {
+  return [
+    '#!/bin/sh',
+    'if [ -n "$MEMOC_RUNTIME_DIR" ]; then',
+    '  memoc_runtime="$MEMOC_RUNTIME_DIR"',
+    'else',
+    '  memoc_runtime="${HOME:-$PWD}/.local/share/memoc/runtime"',
+    'fi',
+    'memoc_cli="$memoc_runtime/bin/cli.js"',
+    'if [ -f "$memoc_cli" ]; then',
+    '  exec node "$memoc_cli" "$@"',
+    'fi',
+    'exec npx @kevin0181/memoc@latest "$@"',
+    '',
+  ].join('\n');
 }
 
 function defaultUserBinDir() {
@@ -249,11 +379,11 @@ function tplEnvSh() {
 }
 
 function ensurePathHelpers(dir, mark) {
-  const cliPath = ensureRuntimeInstall(mark);
+  ensureRuntimeInstall(mark);
   const files = [
-    [path.join(dir, '.memoc', 'bin', 'memoc.cmd'), () => tplMemocCmdWrapper(cliPath), false],
-    [path.join(dir, '.memoc', 'bin', 'memoc.ps1'), () => tplMemocPs1Wrapper(cliPath), false],
-    [path.join(dir, '.memoc', 'bin', 'memoc'), () => tplMemocShWrapper(cliPath), true],
+    [path.join(dir, '.memoc', 'bin', 'memoc.cmd'), tplMemocCmdWrapper, false],
+    [path.join(dir, '.memoc', 'bin', 'memoc.ps1'), tplMemocPs1Wrapper, false],
+    [path.join(dir, '.memoc', 'bin', 'memoc'), tplMemocShWrapper, true],
     [path.join(dir, '.memoc', 'env.ps1'), tplEnvPs1, false],
     [path.join(dir, '.memoc', 'env.sh'), tplEnvSh, true],
   ];
@@ -268,15 +398,16 @@ function ensurePathHelpers(dir, mark) {
 
 function ensureUserLauncher(mark) {
   const userBin = defaultUserBinDir();
-  writeLaunchers(userBin, mark, 'user bin', ensureRuntimeInstall(mark));
+  ensureRuntimeInstall(mark);
+  writeLaunchers(userBin, mark, 'user bin');
   return userBin;
 }
 
-function writeLaunchers(binDir, mark, label, cliPath = ensureRuntimeInstall(mark)) {
+function writeLaunchers(binDir, mark, label) {
   const files = [
-    [path.join(binDir, 'memoc.cmd'), () => tplMemocCmdWrapper(cliPath), false],
-    [path.join(binDir, 'memoc.ps1'), () => tplMemocPs1Wrapper(cliPath), false],
-    [path.join(binDir, 'memoc'), () => tplMemocShWrapper(cliPath), true],
+    [path.join(binDir, 'memoc.cmd'), tplMemocCmdWrapper, false],
+    [path.join(binDir, 'memoc.ps1'), tplMemocPs1Wrapper, false],
+    [path.join(binDir, 'memoc'), tplMemocShWrapper, true],
   ];
 
   for (const [fp, tpl, executable] of files) {
@@ -373,7 +504,8 @@ function ensureCurrentPathLauncher(mark) {
     mark('skip', 'active PATH launcher (no writable PATH directory found)');
     return false;
   }
-  writeLaunchers(target, mark, 'active PATH', ensureRuntimeInstall(mark));
+  ensureRuntimeInstall(mark);
+  writeLaunchers(target, mark, 'active PATH');
   return true;
 }
 
@@ -604,6 +736,9 @@ function managedBlock() {
 - [ ] Search memory first: \`memoc search "<query>" --limit 5\`, or wrapper fallback above if PATH fails
 - [ ] Open on demand: \`02\` status, \`04\` resume, \`06\` rules, \`llms.txt\` map
 - [ ] If memory search is not enough, search project files with \`memoc grep "<query>" --limit 5\` (or wrapper fallback)
+- [ ] If asked to refresh/update memoc project memory, run \`memoc update\` first; this refreshes managed sections, wiki links, and Obsidian tags.
+- [ ] For durable source material use \`memoc ingest <path-or-url>\`; for durable analysis/query results use \`memoc note "<title>"\`; after wiki edits run \`memoc lint-wiki\`.
+- [ ] In shared repos, record meaningful work with \`memoc work "<title>"\`; actor defaults to \`MEMOC_ACTOR\`, local actor, git user, git email, or OS user.
 - [ ] Keep output small: \`summary\`, \`search --limit\`, \`grep --limit\`, \`--snippets\`
 
 ## Before Finishing _(update only applicable files; skip Q&A / throwaway exploration)_
@@ -612,6 +747,9 @@ function managedBlock() {
 - [ ] Work incomplete or risky? Update \`04-handoff.md\`
 - [ ] Rule/preference set? Update \`06-project-rules.md\`
 - [ ] Wiki/systems work? Read \`skills/project-memory-maintainer/SKILL.md\`
+- [ ] User asked to update memoc/project memory? Run \`memoc update\`, then update the smallest relevant agent-owned memory files.
+- [ ] Shared repo work? Prefer \`memoc work "<title>" --from-git\` over appending shared files; run \`memoc activity --write\` only when regenerating indexes.
+- [ ] Keep \`session-summary.md\` as a replace-only snapshot under 800B; move completed work to actor worklogs and resume risks to \`04-handoff.md\`. If it grew, run \`memoc trim-summary\`.
 ${MGMT_E}`;
 }
 
@@ -646,8 +784,9 @@ function coreLlmsInner() {
 - [Project Brief](.memoc/00-project-brief.md): short identity and direction.
 - [Workflow](.memoc/01-agent-workflow.md): update trigger matrix.
 - [Decisions](.memoc/03-decisions.md): durable decisions.
-- [Log](.memoc/log.md): append-only history.
 - [Systems](.memoc/systems/README.md): subsystem docs.
+- [Activity](.memoc/activity.md): generated worklog index.
+- [Raw Sources](.memoc/raw/README.md): immutable source material; do not read by default.
 - [Wiki](.memoc/wiki/index.md): synthesized knowledge.`;
 }
 
@@ -741,6 +880,217 @@ function ensureWikiScaffoldLinks(memDir, mark) {
   }
 }
 
+function ensureObsidianFrontmatter(dir, mark) {
+  const files = collectMemocMarkdownFiles(dir);
+  let changed = 0;
+  for (const fp of files) {
+    if (ensureMemocFrontmatter(fp, dir)) changed += 1;
+  }
+  mark(changed ? 'update' : 'skip', `Obsidian tags (${changed || 'already present'})`);
+}
+
+function collectMemocMarkdownFiles(dir) {
+  const files = [];
+  function walk(root) {
+    if (!fs.existsSync(root)) return;
+    try {
+      const st = fs.statSync(root);
+      if (st.isFile()) {
+        if (root.endsWith('.md')) files.push(root);
+        return;
+      }
+      if (!st.isDirectory()) return;
+      for (const entry of fs.readdirSync(root)) walk(path.join(root, entry));
+    } catch {}
+  }
+  walk(path.join(dir, '.memoc'));
+  walk(path.join(dir, 'skills', 'project-memory-maintainer'));
+  return files.sort();
+}
+
+function ensureMemocFrontmatter(filePath, dir) {
+  let src = '';
+  try { src = fs.readFileSync(filePath, 'utf8'); } catch { return false; }
+  const spec = obsidianFrontmatterSpec(path.relative(dir, filePath));
+  const next = mergeYamlFrontmatter(src, spec);
+  if (next === src) return false;
+  write(filePath, next);
+  return true;
+}
+
+function obsidianFrontmatterSpec(relPath) {
+  const rel = relPath.replace(/\\/g, '/');
+  let type = 'core';
+  const tags = ['memoc'];
+  const now = nowISO();
+  const extra = {
+    created: now,
+    updated: now,
+    status: 'active',
+  };
+
+  if (rel.startsWith('.memoc/wiki/')) {
+    type = 'wiki';
+    extra.confidence = 'medium';
+    tags.push('memoc/wiki');
+    if (rel.startsWith('.memoc/wiki/sources/')) {
+      tags.push('memoc/source');
+      extra.status = 'needs-synthesis';
+    } else if (rel.startsWith('.memoc/wiki/topics/')) {
+      tags.push('memoc/topic');
+    } else if (rel.startsWith('.memoc/wiki/global/')) {
+      tags.push('memoc/global');
+    } else if (rel.endsWith('/sources.md')) {
+      tags.push('memoc/source');
+    } else if (rel.endsWith('/glossary.md')) {
+      tags.push('memoc/glossary');
+    } else if (rel.endsWith('/questions.md')) {
+      tags.push('memoc/question');
+      extra.status = 'needs-review';
+    } else if (rel.endsWith('/lint.md')) {
+      tags.push('memoc/lint');
+      extra.status = 'generated';
+    }
+  } else if (rel.startsWith('.memoc/systems/')) {
+    type = 'system';
+    tags.push('memoc/system');
+  } else if (rel.startsWith('.memoc/raw/')) {
+    type = 'raw';
+    tags.push('memoc/raw');
+  } else if (rel.startsWith('.memoc/worklog/')) {
+    type = 'worklog';
+    tags.push('memoc/worklog');
+  } else if (rel.startsWith('.memoc/actors/')) {
+    type = 'actor';
+    tags.push('memoc/actor');
+  } else if (rel.startsWith('skills/project-memory-maintainer/')) {
+    type = 'skill';
+    tags.push('memoc/skill');
+  } else if (/(session-summary|current-project-state|handoff|project-rules|decisions|log)\.md$/.test(rel)) {
+    type = 'state';
+    tags.push('memoc/state');
+  } else {
+    tags.push('memoc/core');
+  }
+
+  return { type, tags, extra };
+}
+
+function mergeYamlFrontmatter(src, spec) {
+  const fm = parseYamlFrontmatter(src);
+  if (!fm) {
+    return `${formatMemocFrontmatter(spec)}\n${String(src || '').replace(/^\uFEFF/, '')}`;
+  }
+
+  let body = fm.body;
+  let rest = String(src || '').slice(fm.end).replace(/^\uFEFF/, '');
+  const nested = parseYamlFrontmatter(rest);
+  if (nested) {
+    body = `${nested.body}\n${body}`;
+    rest = rest.slice(nested.end).replace(/^\uFEFF/, '');
+  }
+
+  const lines = body.split(/\r?\n/);
+  const existingTags = readYamlTags(lines);
+  const mergedTags = [...new Set([...existingTags, ...spec.tags])];
+  const nextLines = mergeYamlScalar(lines, 'memoc', 'true');
+  mergeYamlScalar(nextLines, 'type', spec.type);
+  mergeYamlScalar(nextLines, 'scope', 'project-memory');
+  mergeYamlScalarIfMissing(nextLines, 'updated', spec.extra.updated);
+  mergeYamlScalarIfMissing(nextLines, 'created', spec.extra.created);
+  mergeYamlScalarIfMissing(nextLines, 'status', spec.extra.status);
+  if (spec.extra.confidence) mergeYamlScalarIfMissing(nextLines, 'confidence', spec.extra.confidence);
+  mergeYamlTags(nextLines, mergedTags);
+
+  const nextFm = ['---', ...nextLines, '---'].join('\n');
+  return `${nextFm}\n${rest.replace(/^\r?\n/, '')}`;
+}
+
+function parseYamlFrontmatter(src) {
+  const text = String(src || '').replace(/^\uFEFF/, '');
+  const offset = text.length === src.length ? 0 : 1;
+  if (!text.startsWith('---\n') && !text.startsWith('---\r\n')) return null;
+  const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+  if (!m) return null;
+  return { body: m[1], end: m[0].length + offset };
+}
+
+function formatMemocFrontmatter(spec) {
+  return [
+    '---',
+    'memoc: true',
+    `type: ${spec.type}`,
+    'scope: project-memory',
+    `created: ${spec.extra.created}`,
+    `updated: ${spec.extra.updated}`,
+    `status: ${spec.extra.status}`,
+    ...(spec.extra.confidence ? [`confidence: ${spec.extra.confidence}`] : []),
+    'tags:',
+    ...spec.tags.map(tag => `  - ${tag}`),
+    '---',
+  ].join('\n');
+}
+
+function mergeYamlScalar(lines, key, value) {
+  const re = new RegExp(`^${escapeRegExp(key)}\\s*:`);
+  const idx = lines.findIndex(line => re.test(line.trim()));
+  if (idx === -1) lines.push(`${key}: ${value}`);
+  else lines[idx] = `${key}: ${value}`;
+  return lines;
+}
+
+function mergeYamlScalarIfMissing(lines, key, value) {
+  const re = new RegExp(`^${escapeRegExp(key)}\\s*:`);
+  if (lines.findIndex(line => re.test(line.trim())) === -1) lines.push(`${key}: ${value}`);
+  return lines;
+}
+
+function mergeYamlTags(lines, tags) {
+  const idx = lines.findIndex(line => /^tags\s*:/.test(line.trim()));
+  const tagLines = ['tags:', ...tags.map(tag => `  - ${tag}`)];
+  if (idx === -1) {
+    lines.push(...tagLines);
+    return;
+  }
+
+  let end = idx + 1;
+  while (end < lines.length && (/^\s+-\s+/.test(lines[end]) || lines[end].trim() === '')) end += 1;
+  lines.splice(idx, end - idx, ...tagLines);
+}
+
+function readYamlTags(lines) {
+  const tags = [];
+  const inline = lines.find(line => /^tags\s*:\s*\[/.test(line.trim()));
+  if (inline) {
+    const m = inline.match(/\[(.*)\]/);
+    if (m) {
+      for (const item of m[1].split(',')) {
+        const tag = item.trim().replace(/^['"]|['"]$/g, '').replace(/^#/, '');
+        if (tag) tags.push(tag);
+      }
+    }
+  }
+
+  const idx = lines.findIndex(line => /^tags\s*:/.test(line.trim()));
+  if (idx !== -1) {
+    for (let i = idx + 1; i < lines.length; i++) {
+      const m = lines[i].match(/^\s+-\s+(.+?)\s*$/);
+      if (!m) {
+        if (lines[i].trim() === '') continue;
+        break;
+      }
+      const tag = m[1].trim().replace(/^['"]|['"]$/g, '').replace(/^#/, '');
+      if (tag) tags.push(tag);
+    }
+  }
+
+  return [...new Set(tags)];
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 // ═══════════════════════════════════════════════════════════════════
 // TEMPLATES — entry files
 // ═══════════════════════════════════════════════════════════════════
@@ -872,8 +1222,11 @@ ${SNAP_E}
 - [Done Checklist](05-done-checklist.md)
 - [Project Rules](06-project-rules.md)
 - [Session Summary](session-summary.md)
-- [Project Log](log.md)
+- [Activity](activity.md)
+- [Actors](actors/README.md)
+- [Worklog](worklog/README.md)
 - [Wiki Index](wiki/index.md)
+- [Raw Sources](raw/README.md)
 - [Systems Index](systems/README.md)
 
 ## System Docs
@@ -911,7 +1264,7 @@ _None yet._
 
 ## Completed Tasks
 
-See \`.memoc/log.md\` for full history.
+See \`.memoc/worklog/\` for full shared activity history.
 
 ## Commands
 
@@ -923,14 +1276,16 @@ _None yet._
 
 ## Change Log
 
-See \`.memoc/log.md\`.
+See \`.memoc/worklog/\` and generated \`.memoc/activity.md\`.
 `;
 }
 
 function tplSessionSummary() {
   return `# Session Summary
 Last: ${nowISO()}
-Keep each section ≤ 3 bullets. Agent-owned — updated by you, not by \`memoc update\`.
+Replace this file instead of appending to it. Keep total size <800B and each section ≤3 bullets.
+Completed history belongs in actor worklogs; incomplete/risky resume detail belongs in \`04-handoff.md\`.
+Agent-owned — updated by you, not by \`memoc update\`.
 
 ## Status
 _What is the current state of the project?_
@@ -966,7 +1321,6 @@ On-demand reference only. The entry-file managed block is authoritative.
 | \`.memoc/01-agent-workflow.md\` | When update routing is unclear |
 | \`.memoc/05-done-checklist.md\` | Before finishing substantial work |
 | \`.memoc/03-decisions.md\` | When a durable decision was made |
-| \`.memoc/log.md\` | For append-only history |
 | \`.memoc/memoc-usage.md\` | For command details |
 | \`.memoc/systems/*.md\` | Before touching a specific subsystem |
 | \`.memoc/wiki/*.md\` | For synthesized project knowledge |
@@ -998,12 +1352,17 @@ Shared protocol for any coding agent.
 
 | Trigger | Update |
 | --- | --- |
-| User creates or changes a requirement | \`02-current-project-state.md\`, \`06-project-rules.md\`, \`log.md\` |
-| Code, config, data, or assets changed | \`02-current-project-state.md\`, relevant \`systems/*.md\`, \`log.md\` |
+| User asks "update memoc", "refresh project memory", or similar | Run \`memoc update\` first, then update relevant agent-owned memory files |
+| User creates or changes a requirement | \`02-current-project-state.md\`, \`06-project-rules.md\`, \`memoc work "<title>" --from-git\` |
+| Code, config, data, or assets changed | \`02-current-project-state.md\`, relevant \`systems/*.md\`, \`memoc work "<title>" --from-git\` |
 | Architecture or system behavior changed | relevant \`systems/*.md\`, \`03-decisions.md\` |
 | A decision should affect future agents | \`03-decisions.md\`, \`02-current-project-state.md\` |
-| Work is substantial enough to resume later | \`04-handoff.md\`, \`02-current-project-state.md\`, \`log.md\` |
+| Work is substantial enough to resume later | \`04-handoff.md\`, \`02-current-project-state.md\`, \`memoc work "<title>" --from-git\` |
 | Durable knowledge was learned | \`wiki/*.md\`, \`wiki/index.md\` |
+| Source material should feed the wiki | \`memoc ingest <path-or-url>\`, then synthesize affected \`wiki/topics/*.md\` |
+| A useful query answer should persist | \`memoc note "<title>"\`, then link related sources/topics |
+| Shared repo work should be traceable | \`memoc work "<title>"\`; avoid appending long details to shared core files |
+| \`session-summary.md\` exceeds 800B or starts accumulating history | Run \`memoc trim-summary\`; move completed history to worklog, resume details to \`04-handoff.md\` |
 
 ## Usually No Update Needed
 
@@ -1014,11 +1373,11 @@ Shared protocol for any coding agent.
 ## Documentation Shape
 
 - Entry files: protocol only.
-- \`session-summary.md\`: latest snapshot, max 3 bullets per section.
+- \`session-summary.md\`: replace-only latest snapshot, <800B, max 3 bullets per section; never use as history.
 - \`02-current-project-state.md\`: current status, tasks, commands, recent notes.
 - \`04-handoff.md\`: resume context, blockers, verified/unverified checks.
 - \`03-decisions.md\`: append durable decisions only.
-- \`log.md\`: full history; keep bulky completed work here.
+- \`worklog/<actor>/YYYY-MM/*.md\`: actor-scoped append-by-new-file activity records for shared repos.
 - \`systems/*.md\` and \`wiki/*.md\`: on-demand durable knowledge.
 `;
 }
@@ -1090,7 +1449,7 @@ Run through this before saying substantial work is complete.
 - [ ] \`.memoc/02-current-project-state.md\` reflects the new status.
 - [ ] \`.memoc/03-decisions.md\` updated if a durable decision was made.
 - [ ] \`.memoc/04-handoff.md\` updated if work is incomplete or risky.
-- [ ] \`.memoc/log.md\` has a new entry for meaningful work.
+- [ ] Meaningful shared work has a \`.memoc/worklog/<actor>/YYYY-MM/*.md\` entry.
 - [ ] Relevant \`.memoc/systems/*.md\` or wiki pages updated.
 
 ## Communication
@@ -1115,7 +1474,7 @@ Durable user and project preferences live here. Update when the user gives a rul
 ## Agent Behavior Preferences
 
 - Be factual and operational in memory docs.
-- Keep logs concise; do not paste temporary command output unless it changes future work.
+- Keep memory notes concise; do not paste temporary command output unless it changes future work.
 - Preserve user changes and avoid reverting unrelated work.
 - State unverified parts honestly in the final answer and handoff.
 
@@ -1128,9 +1487,75 @@ _None yet._
 function tplLog() {
   return `# Project Log
 
-Append-only chronological log for project memory updates.
+Legacy file. New memoc activity belongs in actor worklogs under \`.memoc/worklog/\`.
+
+This file is no longer created for new projects. Existing projects may delete it after migrating useful entries to worklogs.
+`;
+}
+
+function tplActivity() {
+  return `# Activity
+
+Shared activity index for memoc work logs.
+
+## How To Use
+
+- Use \`memoc work "<title>"\` after meaningful work so shared repos get conflict-light per-actor records.
+- Keep this file short; detailed work belongs in [worklog](worklog/README.md).
+- Actor is detected from \`MEMOC_ACTOR\`, \`.memoc/local/actor\`, git config, git email, or OS user.
+
+## Recent Work
+
+_None yet._
+
+## Related
+
+- [Actors](actors/README.md)
+- [Worklog](worklog/README.md)
+`;
+}
+
+function tplActorsReadme() {
+  return `# Actors
+
+People or agents that update memoc in this shared repo.
+
+## Actor Detection
 
-## [${nowISO()}] init | Initialized memoc memory structure.
+1. \`MEMOC_ACTOR\`
+2. \`.memoc/local/actor\` set by \`memoc actor set <name>\`
+3. \`git config user.name\`
+4. \`git config user.email\`
+5. OS username
+
+\`.memoc/local/\` is ignored by git so each machine can keep its own actor setting.
+
+## Actors
+
+_None yet. Use \`memoc actor set <name>\` or \`memoc work "<title>"\`._
+`;
+}
+
+function tplWorklogReadme() {
+  return `# Worklog
+
+Conflict-light per-actor work records.
+
+## Rules
+
+- Prefer creating new worklog files over appending shared core memory files.
+- Keep \`session-summary.md\` as the tiny current snapshot.
+- Put detailed completed work here; put only team-critical unfinished risk in \`04-handoff.md\`.
+
+## Layout
+
+\`\`\`text
+worklog/<actor>/YYYY-MM/YYYYMMDDTHHMM-title.md
+\`\`\`
+
+## Recent Work
+
+_None yet._
 `;
 }
 
@@ -1154,6 +1579,15 @@ memoc upgrade
 
 # Explicitly update managed sections based on current project state
 memoc update
+memoc trim-summary
+
+# Shared repo actor/work tracking
+memoc actor
+memoc actor set neneee
+memoc work "Auth refresh fix" --from-git
+memoc activity
+memoc activity --write
+memoc doctor
 
 # Tiny status overview
 memoc summary
@@ -1165,6 +1599,11 @@ memoc search "<query>" --snippets --limit 5
 # Search project source/text files when memory is not enough
 memoc grep "<query>" --limit 12
 memoc grep "<query>" --snippets --limit 5
+
+# Wiki operations
+memoc ingest <path-or-url>
+memoc note "Durable topic or query result"
+memoc lint-wiki
 \`\`\`
 
 If \`memoc\` is not on PATH, use \`.\\.memoc\\bin\\memoc.cmd <command>\` on Windows or \`.memoc/bin/memoc <command>\` in sh for the rest of the session. If the local wrapper is missing, use \`npx @kevin0181/memoc <command>\` or re-run init.
@@ -1180,30 +1619,55 @@ If \`memoc\` is not on PATH, use \`.\\.memoc\\bin\\memoc.cmd <command>\` on Wind
 
 Use \`memoc search\` for known concepts, changed areas, decisions, tasks, or handoff notes. Skip it for brand-new questions where no prior memory can exist.
 
+Raw files under \`.memoc/raw/\` are intentionally not part of normal memory search. Open them only through a linked source record when provenance is needed.
+
+## Shared Repo Activity
+
+Use \`memoc work "<title>" --from-git\` to create conflict-light activity records under \`.memoc/worklog/<actor>/YYYY-MM/\`. The command prefills actor, branch, timestamp, and changed files from git so agents only need to fill short Summary/Verification notes when useful. Actor is detected in this order: \`MEMOC_ACTOR\`, \`.memoc/local/actor\`, \`git config user.name\`, \`git config user.email\`, OS username. Use \`memoc actor set <name>\` to store a local actor name without committing it.
+
+\`.memoc/activity.md\`, \`.memoc/worklog/README.md\`, and \`.memoc/actors/README.md\` are regenerated indexes. Run \`memoc activity --write\` to rebuild them from worklog/actor files instead of appending to them during every task.
+
 ## When To Run Memory Updates
 
 Use \`memoc update\` or \`skills/project-memory-maintainer/SKILL.md\` when:
 
+- The user asks to update memoc, refresh project memory, sync project memory, or "update the project in memoc".
 - Requirements, acceptance criteria, user preferences, or project rules changed.
 - Source code, config, data, content, or package scripts changed.
 - Architecture, data flow, routing, auth, or deployment behavior changed.
 - A decision was made that future agents should not revisit blindly.
 - Work is partial, multi-step, blocked, or likely to be resumed by another agent.
 - New durable knowledge belongs in \`.memoc/wiki/\` or a subsystem doc.
+- Shared work should be traceable without causing conflicts.
 
 Usually skip for pure Q&A, throwaway exploration, or tiny edits with no future impact.
 
+When the user asks for a general memoc/project-memory refresh, run \`memoc update\` first. It refreshes managed sections, reconnects default wiki scaffold links, and applies Obsidian frontmatter tags. Then update only the agent-owned files whose content actually changed, such as \`.memoc/session-summary.md\`, \`.memoc/02-current-project-state.md\`, \`.memoc/04-handoff.md\`, \`.memoc/wiki/index.md\`, or actor worklogs.
+
+\`.memoc/session-summary.md\` is a startup snapshot, not a timeline. Rewrite it in place, do not append old work. If it exceeds 800B, run \`memoc trim-summary\`; it archives the previous summary and rewrites a compact version. Put completed history in actor worklogs, and put unfinished/risky resume detail in \`.memoc/04-handoff.md\`.
+
 ## Updating The Wiki
 
 Create a new Markdown file under \`.memoc/wiki/\` when synthesized knowledge should compound across sessions.
 
+- \`.memoc/raw/\`: immutable source material copied or referenced by \`memoc ingest\`.
 - \`.memoc/wiki/sources/\`: provenance records.
 - \`.memoc/wiki/topics/\`: synthesized topic pages.
 - \`.memoc/wiki/global/\`: project-wide principles.
 
 After creating or editing wiki pages:
 1. Update \`.memoc/wiki/index.md\`.
-2. Append \`.memoc/log.md\`.
+2. Run \`memoc lint-wiki\`.
+3. If the change is meaningful shared work, run \`memoc work "<title>" --from-git\`.
+
+Useful scaffolds:
+
+\`\`\`bash
+memoc ingest path/to/source.md
+memoc ingest https://example.com/spec
+memoc note "Auth flow comparison"
+memoc lint-wiki
+\`\`\`
 
 ## Updating System Docs
 
@@ -1232,6 +1696,74 @@ Create a new \`.md\` file here when a subsystem becomes important enough that fu
 `;
 }
 
+function tplRawReadme() {
+  return `# Raw Sources
+
+Immutable source material for the memoc wiki.
+
+## Rules
+
+- Do not edit raw files after ingest; create a new raw file or source record when material changes.
+- Do not read raw files at session start. Search or open the linked source/topic page first.
+- Source records under [wiki/sources](../wiki/sources/README.md) summarize raw material and link to affected topics.
+
+## Subdirectories
+
+- [files](files/README.md) — local files copied during ingest
+- [urls](urls/README.md) — URL references and fetched/exported material
+- [conversations](conversations/README.md) — conversation excerpts worth preserving
+- [docs](docs/README.md) — external docs, specs, and long references
+`;
+}
+
+function tplRawFilesReadme() {
+  return `# Raw Files
+
+Local files copied by \`memoc ingest <path>\`.
+
+## Related
+
+- [Raw Sources](../README.md)
+- [Source Records](../../wiki/sources/README.md)
+`;
+}
+
+function tplRawUrlsReadme() {
+  return `# Raw URLs
+
+URL references recorded by \`memoc ingest <url>\`.
+
+## Related
+
+- [Raw Sources](../README.md)
+- [Source Records](../../wiki/sources/README.md)
+`;
+}
+
+function tplRawConversationsReadme() {
+  return `# Raw Conversations
+
+Conversation excerpts that should feed durable wiki synthesis.
+
+## Related
+
+- [Raw Sources](../README.md)
+- [Source Records](../../wiki/sources/README.md)
+`;
+}
+
+function tplRawDocsReadme() {
+  return `# Raw Docs
+
+Long-form docs, specs, and references kept separate from synthesized topic pages.
+
+## Related
+
+- [Raw Sources](../README.md)
+- [Source Records](../../wiki/sources/README.md)
+`;
+}
+
 function tplWikiIndex() {
   return `# Wiki Index
 
@@ -1239,6 +1771,7 @@ Persistent LLM-maintained project wiki.
 
 ## Graph Hubs
 
+- [Raw Sources](../raw/README.md) — immutable source material before synthesis.
 - [Sources](sources.md) — provenance, ingests, and source-to-topic links.
 - [Topics](topics/README.md) — synthesized topic pages.
 - [Global](global/README.md) — project-wide principles and long-lived direction.
@@ -1250,6 +1783,10 @@ Persistent LLM-maintained project wiki.
 
 _None yet. Add every wiki page here with a relative Markdown link and one-line summary._
 
+## Saved Queries
+
+_None yet. Use \`memoc note "<title>"\` for durable analysis or query results that should become a topic._
+
 ## Subdirectories
 
 - [sources/](sources/README.md) — provenance records
@@ -1261,7 +1798,6 @@ _None yet. Add every wiki page here with a relative Markdown link and one-line s
 - [Agent Index](../00-agent-index.md)
 - [Project Brief](../00-project-brief.md)
 - [Current Project State](../02-current-project-state.md)
-- [Project Log](../log.md)
 `;
 }
 
@@ -1274,9 +1810,12 @@ Provenance index for conversations, URLs, docs, issues, and files that feed the
 
 _No sources recorded yet. Link each source record to the topic/global pages it affects._
 
+Use \`memoc ingest <path-or-url>\` to create source records without loading raw material into startup context.
+
 ## Related
 
 - [Wiki Index](index.md)
+- [Raw Sources](../raw/README.md)
 - [Source Records Directory](sources/README.md)
 - [Topics](topics/README.md)
 - [Open Questions](questions.md)
@@ -1326,6 +1865,7 @@ Provenance records for conversations, URLs, docs, and issues.
 
 ## How To Link
 
+- Keep source pages short: summary, raw location, affected pages, open synthesis work.
 - Link each source record back to [Sources](../sources.md).
 - Link outward to every topic, global page, system doc, or question that the source changes.
 - Prefer one source per file when the source is substantial enough to cite later.
@@ -1432,18 +1972,25 @@ Use this local skill after meaningful project work so future agents can continue
 
 ## Maintenance Checklist
 
+- If the user asked to update/refresh memoc project memory, run \`memoc update\` first so managed sections, wiki scaffold links, and Obsidian tags are current.
 - Keep \`llms.txt\` and \`.memoc/00-agent-index.md\` as concise maps.
 - Keep \`.memoc/00-project-brief.md\` as the shortest project summary.
+- Rewrite \`.memoc/session-summary.md\` as the latest snapshot only; never append a timeline. If it is over 800B, run \`memoc trim-summary\`.
 - Update \`.memoc/02-current-project-state.md\` with new status, tasks, commands, and change log entries.
 - Update \`.memoc/03-decisions.md\` when a durable decision is made.
 - Update \`.memoc/04-handoff.md\` before ending substantial work.
 - Check \`.memoc/05-done-checklist.md\` before saying substantial work is complete.
 - Update \`.memoc/06-project-rules.md\` when the user gives durable preferences.
-- Append \`.memoc/log.md\` for meaningful changes, decisions, and handoffs.
+- Create a short actor worklog with \`memoc work "<title>" --from-git\` for meaningful changes, decisions, and handoffs.
 - Create or update \`.memoc/systems/*.md\` when a subsystem needs durable explanation.
 - Create or update \`.memoc/wiki/*.md\` when synthesized knowledge should compound over time.
+- Use \`memoc ingest <path-or-url>\` for source material and \`memoc note "<title>"\` for durable query results or analysis.
+- Use \`memoc work "<title>" --from-git\` for meaningful shared-repo work so details are saved in actor-scoped worklog files instead of causing shared-file conflicts.
 - Keep the wiki graph connected: update \`.memoc/wiki/index.md\`, add relative Markdown links between related pages, and include a \`## Related\` section on every new wiki page.
-- Keep completed history in \`.memoc/log.md\`; keep current-state files short.
+- Run \`memoc lint-wiki\` after wiki/source/topic edits and address broken links before finishing.
+- Keep completed history in actor worklogs; keep current-state files short.
+- Move completed session details out of \`session-summary.md\` into \`.memoc/worklog/<actor>/YYYY-MM/\`; move incomplete/risky resume details into \`04-handoff.md\`.
+- In shared repos, do not use \`log.md\`; prefer new files under \`.memoc/worklog/<actor>/YYYY-MM/\` and regenerate \`.memoc/activity.md\` with \`memoc activity --write\`.
 - Keep tool output small; prefer \`summary\`, file-only search, \`--limit\`, and targeted reads.
 
 ## Wiki Link Rules
@@ -1552,17 +2099,16 @@ function ensureClaudeStopHookFile(dir, mark) {
 
 function ensurePendingGitignore(dir, mark) {
   const gitignorePath = path.join(dir, '.gitignore');
-  const PENDING_ENTRY = '.memoc/.pending';
+  const entries = ['.memoc/.pending', '.memoc/local/'];
   const gitignoreContent = fs.existsSync(gitignorePath)
     ? fs.readFileSync(gitignorePath, 'utf8') : '';
-  const hasPendingEntry = gitignoreContent
-    .split(/\r?\n/)
-    .some(line => line.trim() === PENDING_ENTRY);
-  if (!hasPendingEntry) {
-    fs.appendFileSync(gitignorePath, (gitignoreContent.endsWith('\n') ? '' : '\n') + PENDING_ENTRY + '\n', 'utf8');
-    mark('update', '.gitignore (.memoc/.pending added)');
+  const lines = gitignoreContent.split(/\r?\n/).map(line => line.trim());
+  const missing = entries.filter(entry => !lines.includes(entry));
+  if (missing.length) {
+    fs.appendFileSync(gitignorePath, (gitignoreContent.endsWith('\n') ? '' : '\n') + missing.join('\n') + '\n', 'utf8');
+    mark('update', `.gitignore (${missing.join(', ')} added)`);
   } else {
-    mark('skip', '.gitignore (.memoc/.pending already present)');
+    mark('skip', '.gitignore (memoc local entries already present)');
   }
 }
 
@@ -1637,9 +2183,16 @@ function run(dir, forceUpdate, action = 'update') {
       [path.join(memDir, '04-handoff.md'),             tplHandoff],
       [path.join(memDir, '05-done-checklist.md'),      tplDoneChecklist],
       [path.join(memDir, '06-project-rules.md'),       tplProjectRules],
-      [path.join(memDir, 'log.md'),                    tplLog],
+      [path.join(memDir, 'activity.md'),               tplActivity],
+      [path.join(memDir, 'actors/README.md'),          tplActorsReadme],
+      [path.join(memDir, 'worklog/README.md'),         tplWorklogReadme],
       [path.join(memDir, 'memoc-usage.md'),    tplMemocUsage],
       [path.join(memDir, 'systems/README.md'),         tplSystemsReadme],
+      [path.join(memDir, 'raw/README.md'),             tplRawReadme],
+      [path.join(memDir, 'raw/files/README.md'),       tplRawFilesReadme],
+      [path.join(memDir, 'raw/urls/README.md'),        tplRawUrlsReadme],
+      [path.join(memDir, 'raw/conversations/README.md'), tplRawConversationsReadme],
+      [path.join(memDir, 'raw/docs/README.md'),        tplRawDocsReadme],
       [path.join(memDir, 'wiki/index.md'),             tplWikiIndex],
       [path.join(memDir, 'wiki/sources.md'),           tplWikiSources],
       [path.join(memDir, 'wiki/glossary.md'),          tplWikiGlossary],
@@ -1661,6 +2214,9 @@ function run(dir, forceUpdate, action = 'update') {
     // .gitignore — add .memoc/.pending if not already present
     ensurePendingGitignore(dir, mark);
 
+    // Obsidian graph filters — tag memoc-owned Markdown without touching unrelated docs
+    ensureObsidianFrontmatter(dir, mark);
+
     // PATH helpers — let agents run memoc even when the npm bin is not on PATH
     ensurePathHelpers(dir, mark);
     ensurePathRegistration(dir, mark);
@@ -1735,9 +2291,16 @@ function run(dir, forceUpdate, action = 'update') {
       [path.join(memDir, '04-handoff.md'),             tplHandoff],
       [path.join(memDir, '05-done-checklist.md'),      tplDoneChecklist],
       [path.join(memDir, '06-project-rules.md'),       tplProjectRules],
-      [path.join(memDir, 'log.md'),                    tplLog],
+      [path.join(memDir, 'activity.md'),               tplActivity],
+      [path.join(memDir, 'actors/README.md'),          tplActorsReadme],
+      [path.join(memDir, 'worklog/README.md'),         tplWorklogReadme],
       [path.join(memDir, 'memoc-usage.md'),    tplMemocUsage],
       [path.join(memDir, 'systems/README.md'),         tplSystemsReadme],
+      [path.join(memDir, 'raw/README.md'),             tplRawReadme],
+      [path.join(memDir, 'raw/files/README.md'),       tplRawFilesReadme],
+      [path.join(memDir, 'raw/urls/README.md'),        tplRawUrlsReadme],
+      [path.join(memDir, 'raw/conversations/README.md'), tplRawConversationsReadme],
+      [path.join(memDir, 'raw/docs/README.md'),        tplRawDocsReadme],
       [path.join(memDir, 'wiki/index.md'),             tplWikiIndex],
       [path.join(memDir, 'wiki/sources.md'),           tplWikiSources],
       [path.join(memDir, 'wiki/glossary.md'),          tplWikiGlossary],
@@ -1755,21 +2318,16 @@ function run(dir, forceUpdate, action = 'update') {
     }
     ensureWikiScaffoldLinks(memDir, mark);
 
+    // Obsidian graph filters — add/merge memoc tags for existing installs too
+    ensureObsidianFrontmatter(dir, mark);
+
     // PATH helpers — let agents run memoc even when the npm bin is not on PATH
     ensureClaudeStopHookFile(dir, mark);
     ensurePendingGitignore(dir, mark);
     ensurePathHelpers(dir, mark);
     ensurePathRegistration(dir, mark);
 
-    // Append update record to log.md
-    const logPath = path.join(memDir, 'log.md');
-    if (fs.existsSync(logPath)) {
-      fs.appendFileSync(logPath,
-        `\n## [${nowISO()}] ${action} | Re-scanned: ${p.isEmpty ? 'nothing detected' : stackStr(p.stack)}\n`,
-        'utf8'
-      );
-      mark('append', '.memoc/log.md');
-    }
+    mark('skip', '.memoc/log.md (legacy; shared history belongs in worklog)');
   }
 
   hideOnWindows(memDir);
@@ -1808,6 +2366,586 @@ function runAdd(dir) {
   console.log('\n  Done.');
 }
 
+// ═══════════════════════════════════════════════════════════════════
+// ACTOR / WORKLOG — conflict-light shared repo activity tracking
+// ═══════════════════════════════════════════════════════════════════
+
+function runActor(dir) {
+  const sub = (process.argv[3] || '').toLowerCase();
+  if (sub === 'set') {
+    const name = process.argv.slice(4).join(' ').trim();
+    if (!name) {
+      console.error('\n  Usage: memoc actor set <name>');
+      process.exit(1);
+    }
+    const actor = sanitizeActor(name);
+    write(actorFile(dir), `${actor}\n`);
+    ensurePendingGitignore(dir, () => {});
+    console.log('\n  memoc actor\n');
+    console.log(`    Set local actor: ${actor}`);
+    console.log('    Stored in .memoc/local/actor (ignored by git).');
+    console.log();
+    return;
+  }
+
+  const detected = detectActor(dir);
+  console.log('\n  memoc actor\n');
+  console.log(`    Actor   ${detected.actor}`);
+  console.log(`    Source  ${detected.source}`);
+  console.log('\n  Use `memoc actor set <name>` to override locally.\n');
+}
+
+function runWork(dir) {
+  const rawArgs = process.argv.slice(3);
+  const opts = { status: 'done', body: '', fromGit: true };
+  const titleParts = [];
+  for (let i = 0; i < rawArgs.length; i++) {
+    const arg = rawArgs[i];
+    if (arg === '--status') {
+      opts.status = sanitizeActor(rawArgs[++i] || 'done');
+      continue;
+    }
+    if (arg.startsWith('--status=')) {
+      opts.status = sanitizeActor(arg.slice('--status='.length) || 'done');
+      continue;
+    }
+    if (arg === '--body') {
+      opts.body = rawArgs.slice(i + 1).join(' ');
+      break;
+    }
+    if (arg === '--from-git') {
+      opts.fromGit = true;
+      continue;
+    }
+    if (arg === '--no-git') {
+      opts.fromGit = false;
+      continue;
+    }
+    titleParts.push(arg);
+  }
+
+  const title = titleParts.join(' ').trim();
+  if (!title) {
+    console.error('\n  Usage: memoc work "<title>" [--status done|wip|blocked] [--from-git|--no-git] [--body "summary"]');
+    process.exit(1);
+  }
+
+  ensureMemocBase(dir);
+  const detected = detectActor(dir);
+  ensureActorProfile(dir, detected);
+  const stamp = new Date().toISOString().slice(0, 16).replace(/[-:]/g, '').replace('T', 'T');
+  const month = todayISO().slice(0, 7);
+  const fileName = `${stamp}-${slugify(title, 'work')}.md`;
+  const workPath = uniquePath(path.join(dir, '.memoc', 'worklog', detected.actor, month, fileName));
+  write(workPath, worklogRecord(dir, title, detected, opts));
+  ensureMemocFrontmatter(workPath, dir);
+
+  console.log('\n  memoc work\n');
+  console.log(`    Actor   ${detected.actor} (${detected.source})`);
+  console.log(`    Work    ${normRel(dir, workPath)}`);
+  console.log('    Next    Fill only Summary/Verification if needed; run `memoc activity --write` to regenerate indexes.');
+  console.log();
+}
+
+function runActivity(dir) {
+  const writeIndex = process.argv.slice(3).includes('--write');
+  const workRoot = path.join(dir, '.memoc', 'worklog');
+  const files = listMarkdownFiles(workRoot)
+    .filter(fp => path.basename(fp) !== 'README.md')
+    .sort()
+    .reverse();
+  const recent = files.slice(0, 20);
+
+  if (writeIndex) {
+    writeActivityIndexes(dir, recent);
+    ensureObsidianFrontmatter(dir, () => {});
+  }
+
+  console.log('\n  memoc activity\n');
+  if (!recent.length) {
+    console.log('    No worklog entries yet. Use `memoc work "<title>"`.');
+    console.log();
+    return;
+  }
+  for (const fp of recent) {
+    const src = safeRead(fp);
+    const title = markdownTitle(src, path.basename(fp, '.md'));
+    const actor = (src.match(/^actor:\s*(.+)$/m) || [])[1] || 'unknown';
+    const status = (src.match(/^status:\s*(.+)$/m) || [])[1] || 'unknown';
+    console.log(`    - ${normRel(dir, fp)}  ${actor}  ${status}  ${title}`);
+  }
+  if (writeIndex) console.log('\n    Wrote .memoc/activity.md and .memoc/worklog/README.md');
+  console.log();
+}
+
+function ensureActorProfile(dir, detected) {
+  const actorPath = path.join(dir, '.memoc', 'actors', `${detected.actor}.md`);
+  if (fs.existsSync(actorPath)) return;
+  write(actorPath, actorProfile(detected));
+  ensureMemocFrontmatter(actorPath, dir);
+}
+
+function actorProfile(detected) {
+  return `# ${detected.actor}
+
+## Identity
+
+- Actor: ${detected.actor}
+- First detected from: ${detected.source}
+- First seen: ${nowISO()}
+
+## Notes
+
+_Add stable collaboration preferences or ownership notes only when useful._
+
+## Related
+
+- [Actors](README.md)
+- [Activity](../activity.md)
+- [Worklog](../worklog/README.md)
+`;
+}
+
+function worklogRecord(dir, title, detected, opts) {
+  const branch = gitBranch(dir);
+  const changedFiles = opts.fromGit ? gitStatusFiles(dir) : [];
+  return `# ${title}
+
+actor: ${detected.actor}
+actor_source: ${detected.source}
+branch: ${branch}
+status: ${opts.status}
+created: ${nowISO()}
+
+## Summary
+
+${opts.body ? `- ${opts.body}` : '_1-3 bullets only. Keep this as a short receipt, not a report._'}
+
+## Changed Files
+
+${changedFiles.length ? changedFiles.map(file => `- \`${file}\``).join('\n') : '_None detected. Use `memoc work "<title>" --from-git` after editing files to prefill this section._'}
+
+## Verification
+
+_Commands run or checks not run. Keep to 1-3 bullets._
+
+## Follow-up
+
+_None._
+
+## Related
+
+- [Activity](../../../activity.md)
+- [Worklog](../../README.md)
+- [Actor](../../../actors/${detected.actor}.md)
+`;
+}
+
+function writeActivityIndexes(dir, recentFiles) {
+  const activityPath = path.join(dir, '.memoc', 'activity.md');
+  const worklogReadme = path.join(dir, '.memoc', 'worklog', 'README.md');
+  const actorsReadme = path.join(dir, '.memoc', 'actors', 'README.md');
+  const rows = recentFiles.map(fp => {
+    const src = safeRead(fp);
+    const title = markdownTitle(src, path.basename(fp, '.md'));
+    const actor = (src.match(/^actor:\s*(.+)$/m) || [])[1] || 'unknown';
+    const status = (src.match(/^status:\s*(.+)$/m) || [])[1] || 'unknown';
+    return { fp, title, actor, status };
+  });
+  const activityItems = rows.length
+    ? rows.map(row => `- [${row.title}](${pathRelativeMarkdown(path.join(dir, '.memoc'), row.fp).replace(/^\.\//, '')}) — ${row.actor} ${row.status}.`).join('\n')
+    : '_None yet._';
+  write(activityPath, `# Activity
+
+Generated shared activity index for memoc work logs.
+
+Last generated: ${nowISO()}
+
+## Recent Work
+
+${activityItems}
+
+## Related
+
+- [Actors](actors/README.md)
+- [Worklog](worklog/README.md)
+`);
+
+  const worklogItems = rows.length
+    ? rows.map(row => `- [${row.title}](${pathRelativeMarkdown(path.join(dir, '.memoc', 'worklog'), row.fp).replace(/^\.\//, '')}) — ${row.actor} ${row.status}.`).join('\n')
+    : '_None yet._';
+  write(worklogReadme, `# Worklog
+
+Generated index of conflict-light per-actor work records.
+
+Last generated: ${nowISO()}
+
+## Layout
+
+\`\`\`text
+worklog/<actor>/YYYY-MM/YYYYMMDDTHHMM-title.md
+\`\`\`
+
+## Rules
+
+- Prefer creating new worklog files over appending shared core memory files.
+- Keep worklog entries short: 1-3 summary bullets, key files, verification.
+
+## Recent Work
+
+${worklogItems}
+`);
+
+  const actorFiles = listMarkdownFiles(path.join(dir, '.memoc', 'actors'))
+    .filter(fp => path.basename(fp) !== 'README.md')
+    .sort();
+  const actorItems = actorFiles.length
+    ? actorFiles.map(fp => `- [${markdownTitle(safeRead(fp), path.basename(fp, '.md'))}](${path.basename(fp)})`).join('\n')
+    : '_None yet. Use `memoc actor set <name>` or `memoc work "<title>"`._';
+  write(actorsReadme, `# Actors
+
+Generated actor index for this shared repo.
+
+## Actor Detection
+
+1. \`MEMOC_ACTOR\`
+2. \`.memoc/local/actor\` set by \`memoc actor set <name>\`
+3. \`git config user.name\`
+4. \`git config user.email\`
+5. OS username
+
+\`.memoc/local/\` is ignored by git so each machine can keep its own actor setting.
+
+## Actors
+
+${actorItems}
+`);
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// WIKI OPERATIONS — lint, ingest, and durable topic notes
+// ═══════════════════════════════════════════════════════════════════
+
+function runWikiLint(dir) {
+  ensureObsidianFrontmatter(dir, () => {});
+  const wikiDir = path.join(dir, '.memoc', 'wiki');
+  const files = listMarkdownFiles(wikiDir);
+  const issues = [];
+  const warnings = [];
+  const inbound = new Map(files.map(fp => [normRel(dir, fp), 0]));
+
+  for (const fp of files) {
+    const rel = normRel(dir, fp);
+    const src = safeRead(fp);
+    if (!parseYamlFrontmatter(src)) warnings.push(`${rel}: missing YAML frontmatter`);
+    if (!src.includes('memoc/wiki')) warnings.push(`${rel}: missing memoc/wiki tag`);
+    if (!/^## Related\b/m.test(src) && !rel.endsWith('wiki/index.md')) warnings.push(`${rel}: missing ## Related section`);
+
+    for (const link of markdownLinks(src)) {
+      if (/^[a-z][a-z0-9+.-]*:/i.test(link) || link.startsWith('#')) continue;
+      const target = resolveMarkdownLink(fp, link);
+      if (!target) continue;
+      if (!fs.existsSync(target)) {
+        issues.push(`${rel}: broken link ${link}`);
+        continue;
+      }
+      const targetRel = normRel(dir, target);
+      if (inbound.has(targetRel)) inbound.set(targetRel, inbound.get(targetRel) + 1);
+    }
+  }
+
+  for (const [rel, count] of inbound.entries()) {
+    if (rel.endsWith('wiki/index.md')) continue;
+    if (count === 0) warnings.push(`${rel}: no inbound wiki links`);
+  }
+
+  const lintPath = path.join(wikiDir, 'lint.md');
+  write(lintPath, wikiLintReport(issues, warnings));
+  ensureMemocFrontmatter(lintPath, dir);
+
+  console.log('\n  memoc lint-wiki\n');
+  console.log(`    Files     ${files.length}`);
+  console.log(`    Issues    ${issues.length}`);
+  console.log(`    Warnings  ${warnings.length}`);
+  console.log('    Report    .memoc/wiki/lint.md');
+  if (issues.length) {
+    console.log('\n  Issues:');
+    for (const issue of issues.slice(0, 10)) console.log(`    - ${issue}`);
+  }
+  if (!issues.length && !warnings.length) console.log('\n  No issues found.');
+  console.log();
+}
+
+function wikiLintReport(issues, warnings) {
+  return `# Wiki Lint
+
+Last checked: ${nowISO()}
+
+## Graph Checks
+
+- Every wiki page is listed from [Wiki Index](index.md) or a directory README.
+- Every wiki page links back to an index, hub, source, topic, or related page.
+- Important concepts mentioned in two or more places have their own linked page.
+- Source records link to the pages they update, and those pages link back to sources when provenance matters.
+
+## Issues
+
+${issues.length ? issues.map(x => `- ${x}`).join('\n') : '_No issues found._'}
+
+## Warnings
+
+${warnings.length ? warnings.map(x => `- ${x}`).join('\n') : '_None._'}
+
+## Related
+
+- [Wiki Index](index.md)
+- [Sources](sources.md)
+- [Topics](topics/README.md)
+- [Open Questions](questions.md)
+`;
+}
+
+function runIngest(dir) {
+  const target = process.argv[3];
+  if (!target) {
+    console.error('\n  Usage: memoc ingest <path-or-url>');
+    process.exit(1);
+  }
+
+  ensureMemocBase(dir);
+  const isUrl = /^[a-z][a-z0-9+.-]*:\/\//i.test(target);
+  const title = ingestTitle(dir, target, isUrl);
+  const slug = `${todayISO()}-${slugify(title, 'source')}`;
+  let rawRef;
+  let rawDisplay;
+
+  if (isUrl) {
+    const rawPath = uniquePath(path.join(dir, '.memoc', 'raw', 'urls', `${slug}.md`));
+    write(rawPath, rawUrlRecord(title, target));
+    ensureMemocFrontmatter(rawPath, dir);
+    rawRef = pathRelativeMarkdown(path.join(dir, '.memoc', 'wiki', 'sources'), rawPath);
+    rawDisplay = normRel(dir, rawPath);
+  } else {
+    const abs = path.resolve(dir, target);
+    if (!fs.existsSync(abs) || !fs.statSync(abs).isFile()) {
+      console.error(`\n  Source file not found: ${target}`);
+      process.exit(1);
+    }
+    const ext = path.extname(abs) || '.txt';
+    const rawPath = uniquePath(path.join(dir, '.memoc', 'raw', 'files', `${slug}${ext}`));
+    fs.mkdirSync(path.dirname(rawPath), { recursive: true });
+    fs.copyFileSync(abs, rawPath);
+    rawRef = pathRelativeMarkdown(path.join(dir, '.memoc', 'wiki', 'sources'), rawPath);
+    rawDisplay = normRel(dir, rawPath);
+  }
+
+  const sourcePath = uniquePath(path.join(dir, '.memoc', 'wiki', 'sources', `${slug}.md`));
+  write(sourcePath, sourceRecord(title, rawRef, target, isUrl));
+  ensureMemocFrontmatter(sourcePath, dir);
+  addWikiListItem(path.join(dir, '.memoc', 'wiki', 'sources.md'), 'Source Records', pathRelativeMarkdown(path.join(dir, '.memoc', 'wiki'), sourcePath), title, 'needs synthesis');
+  addWikiListItem(path.join(dir, '.memoc', 'wiki', 'sources', 'README.md'), 'Source Records', path.basename(sourcePath), title, 'source record');
+  addWikiListItem(path.join(dir, '.memoc', 'wiki', 'index.md'), 'Pages', pathRelativeMarkdown(path.join(dir, '.memoc', 'wiki'), sourcePath), title, 'source record');
+  console.log('\n  memoc ingest\n');
+  console.log(`    Source record  ${normRel(dir, sourcePath)}`);
+  console.log(`    Raw reference  ${rawDisplay}`);
+  console.log('    Next           Synthesize affected topics, then run memoc lint-wiki.');
+  console.log();
+}
+
+function runNote(dir) {
+  const rawArgs = process.argv.slice(3);
+  const bodyIndex = rawArgs.indexOf('--body');
+  let body = '';
+  let titleArgs = rawArgs;
+  if (bodyIndex !== -1) {
+    titleArgs = rawArgs.slice(0, bodyIndex);
+    body = rawArgs.slice(bodyIndex + 1).join(' ');
+  }
+  const title = titleArgs.join(' ').trim();
+  if (!title) {
+    console.error('\n  Usage: memoc note "<topic title>" [--body "short note"]');
+    process.exit(1);
+  }
+
+  ensureMemocBase(dir);
+  const topicPath = uniquePath(path.join(dir, '.memoc', 'wiki', 'topics', `${slugify(title, 'topic')}.md`));
+  write(topicPath, topicNote(title, body));
+  ensureMemocFrontmatter(topicPath, dir);
+  addWikiListItem(path.join(dir, '.memoc', 'wiki', 'topics', 'README.md'), 'Topic Pages', path.basename(topicPath), title, 'topic note');
+  addWikiListItem(path.join(dir, '.memoc', 'wiki', 'index.md'), 'Saved Queries', pathRelativeMarkdown(path.join(dir, '.memoc', 'wiki'), topicPath), title, 'saved query/topic note');
+  console.log('\n  memoc note\n');
+  console.log(`    Topic  ${normRel(dir, topicPath)}`);
+  console.log('    Next   Link related sources/topics, then run memoc lint-wiki.');
+  console.log();
+}
+
+function ensureMemocBase(dir) {
+  const p = scanProject(dir);
+  const memDir = path.join(dir, '.memoc');
+  const files = [
+    [path.join(memDir, 'wiki/index.md'), tplWikiIndex],
+    [path.join(memDir, 'wiki/sources.md'), tplWikiSources],
+    [path.join(memDir, 'wiki/sources/README.md'), tplWikiSourcesReadme],
+    [path.join(memDir, 'wiki/topics/README.md'), tplWikiTopicsReadme],
+    [path.join(memDir, 'raw/README.md'), tplRawReadme],
+    [path.join(memDir, 'raw/files/README.md'), tplRawFilesReadme],
+    [path.join(memDir, 'raw/urls/README.md'), tplRawUrlsReadme],
+    [path.join(memDir, 'activity.md'), tplActivity],
+    [path.join(memDir, 'actors/README.md'), tplActorsReadme],
+    [path.join(memDir, 'worklog/README.md'), tplWorklogReadme],
+    [path.join(memDir, '00-agent-index.md'), () => tplAgentIndex(p)],
+  ];
+  for (const [fp, tpl] of files) ensure(fp, tpl());
+  ensureObsidianFrontmatter(dir, () => {});
+}
+
+function ingestTitle(dir, target, isUrl) {
+  if (isUrl) {
+    try {
+      const u = new URL(target);
+      return path.basename(u.pathname) || u.hostname;
+    } catch {
+      return target;
+    }
+  }
+  try {
+    const src = fs.readFileSync(path.resolve(dir, target), 'utf8');
+    return markdownTitle(src, path.basename(target, path.extname(target)));
+  } catch {
+    return path.basename(target, path.extname(target));
+  }
+}
+
+function rawUrlRecord(title, url) {
+  return `# ${title}
+
+Original URL: ${url}
+
+This raw URL record stores provenance only. Summarize it in a source record before using it as durable project knowledge.
+`;
+}
+
+function sourceRecord(title, rawRef, original, isUrl) {
+  return `# ${title}
+
+## Source
+
+- Raw: [${isUrl ? 'URL record' : 'raw file'}](${rawRef})
+- Original: ${original}
+- Ingested: ${nowISO()}
+
+## Summary
+
+_Summarize only the durable facts future agents should reuse._
+
+## Affects
+
+- [Sources](../sources.md)
+- [Topics](../topics/README.md)
+- [Open Questions](../questions.md)
+
+## Synthesis Tasks
+
+- [ ] Create or update affected topic/global/system pages.
+- [ ] Link those pages back to this source when provenance matters.
+- [ ] Run \`memoc lint-wiki\`.
+
+## Related
+
+- [Sources Index](../sources.md)
+- [Source Records](README.md)
+- [Wiki Index](../index.md)
+`;
+}
+
+function topicNote(title, body) {
+  return `# ${title}
+
+## Summary
+
+${body ? `- ${body}` : '_Capture the durable answer, analysis, or query result here._'}
+
+## Evidence
+
+- [Sources](../sources.md)
+
+## Open Questions
+
+_None yet._
+
+## Related
+
+- [Wiki Index](../index.md)
+- [Topics](README.md)
+- [Glossary](../glossary.md)
+`;
+}
+
+function listMarkdownFiles(root) {
+  const files = [];
+  function walk(d) {
+    if (!fs.existsSync(d)) return;
+    for (const entry of fs.readdirSync(d)) {
+      const fp = path.join(d, entry);
+      try {
+        const st = fs.statSync(fp);
+        if (st.isDirectory()) walk(fp);
+        else if (entry.endsWith('.md')) files.push(fp);
+      } catch {}
+    }
+  }
+  walk(root);
+  return files.sort();
+}
+
+function safeRead(fp) {
+  try { return fs.readFileSync(fp, 'utf8'); } catch { return ''; }
+}
+
+function normRel(dir, fp) {
+  return path.relative(dir, fp).replace(/\\/g, '/');
+}
+
+function pathRelativeMarkdown(fromDir, toFile) {
+  let rel = path.relative(fromDir, toFile).replace(/\\/g, '/');
+  if (!rel.startsWith('.')) rel = `./${rel}`;
+  return rel;
+}
+
+function markdownLinks(src) {
+  const links = [];
+  const re = /!?\[[^\]]*]\(([^)\s]+)(?:\s+"[^"]*")?\)/g;
+  let m;
+  while ((m = re.exec(src))) links.push(m[1]);
+  return links;
+}
+
+function resolveMarkdownLink(fromFile, link) {
+  const clean = decodeURIComponent(String(link).split('#')[0]);
+  if (!clean) return null;
+  const base = path.resolve(path.dirname(fromFile), clean);
+  if (path.extname(base)) return base;
+  if (fs.existsSync(`${base}.md`)) return `${base}.md`;
+  return base;
+}
+
+function addWikiListItem(filePath, heading, link, title, note) {
+  const src = safeRead(filePath);
+  if (!src) return;
+  if (src.includes(`](${link})`) || src.includes(`](${link.replace(/^\.\//, '')})`)) return;
+  const item = `- [${title}](${link.replace(/^\.\//, '')}) — ${note}.`;
+  const re = new RegExp(`(## ${escapeRegExp(heading)}\\n)([\\s\\S]*?)(?=\\n## |$)`, 'm');
+  const m = src.match(re);
+  if (!m) {
+    write(filePath, `${src.trimEnd()}\n\n## ${heading}\n\n${item}\n`);
+    return;
+  }
+  const replacementBody = m[2].includes('_None yet') || m[2].includes('_No sources recorded yet')
+    ? `\n${item}\n`
+    : `${m[2].trimEnd()}\n${item}\n`;
+  write(filePath, src.replace(re, `$1${replacementBody}`));
+}
+
 // ═══════════════════════════════════════════════════════════════════
 // SEARCH
 // ═══════════════════════════════════════════════════════════════════
@@ -1971,6 +3109,8 @@ function shouldSkipSearchDir(name, scope = 'memory') {
     skipped.add('.memoc');
     skipped.add('skills');
     skipped.add('.claude');
+  } else {
+    skipped.add('raw');
   }
   return skipped.has(name);
 }
@@ -2015,7 +3155,7 @@ function searchPriority(file, scope = 'memory') {
     '.memoc/04-handoff.md',
     '.memoc/06-project-rules.md',
     '.memoc/03-decisions.md',
-    '.memoc/log.md',
+    '.memoc/activity.md',
     'AGENTS.md',
     'CLAUDE.md',
     'llms.txt',
@@ -2049,7 +3189,7 @@ function runTokens(dir) {
     ['03-decisions.md',               path.join(memDir, '03-decisions.md')],
     ['04-handoff.md',                 path.join(memDir, '04-handoff.md')],
     ['06-project-rules.md',           path.join(memDir, '06-project-rules.md')],
-    ['log.md',                        path.join(memDir, 'log.md')],
+    ['activity.md',                   path.join(memDir, 'activity.md')],
   ];
 
   console.log('\n  memoc tokens\n');
@@ -2082,13 +3222,62 @@ function runTokens(dir) {
   const summaryContent = read(path.join(memDir, 'session-summary.md'));
   const summaryBytes   = Buffer.byteLength(summaryContent, 'utf8');
   if (summaryBytes > 800) {
-    console.log(`\n  ⚠ session-summary.md is ${summaryBytes}B — recommended <800B. Trim it manually.`);
+    console.log(`\n  ⚠ session-summary.md is ${summaryBytes}B — recommended <800B. Run \`memoc trim-summary\`, then move completed history to worklog and resume details to 04-handoff.md.`);
+  }
+  console.log();
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// DOCTOR — quick health checks for shared memoc repos
+// ═══════════════════════════════════════════════════════════════════
+
+function runDoctor(dir) {
+  const issues = [];
+  const warnings = [];
+  const memDir = path.join(dir, '.memoc');
+  const summaryPath = path.join(memDir, 'session-summary.md');
+  const summary = safeRead(summaryPath);
+  if (!summary) issues.push('Missing .memoc/session-summary.md');
+  else if (Buffer.byteLength(summary, 'utf8') > 800) warnings.push('session-summary.md exceeds 800B; run memoc trim-summary');
+
+  for (const fp of [
+    path.join(dir, '.memoc', 'bin', 'memoc'),
+    path.join(dir, '.memoc', 'bin', 'memoc.cmd'),
+    path.join(dir, '.memoc', 'bin', 'memoc.ps1'),
+  ]) {
+    const src = safeRead(fp);
+    if (src && (/C:\\Users\\|\/Users\/[^/]+\/\.local\/share\/memoc\/runtime/.test(src))) {
+      issues.push(`${normRel(dir, fp)} contains a user-specific runtime path; run memoc upgrade`);
+    }
+  }
+
+  for (const fp of collectMemocMarkdownFiles(dir)) {
+    const src = safeRead(fp);
+    const fenceCount = (src.match(/^---$/gm) || []).length;
+    if (fenceCount > 2) warnings.push(`${normRel(dir, fp)} may have nested frontmatter; run memoc upgrade`);
+  }
+
+  const actor = detectActor(dir);
+  if (actor.actor === 'unknown') warnings.push('Actor could not be detected; run memoc actor set <name>');
+
+  console.log('\n  memoc doctor\n');
+  console.log(`    Actor    ${actor.actor} (${actor.source})`);
+  console.log(`    Issues   ${issues.length}`);
+  console.log(`    Warnings ${warnings.length}`);
+  if (issues.length) {
+    console.log('\n  Issues:');
+    for (const issue of issues) console.log(`    - ${issue}`);
+  }
+  if (warnings.length) {
+    console.log('\n  Warnings:');
+    for (const warning of warnings.slice(0, 20)) console.log(`    - ${warning}`);
   }
+  if (!issues.length && !warnings.length) console.log('\n  Looks good.');
   console.log();
 }
 
 // ═══════════════════════════════════════════════════════════════════
-// COMPRESS — archive old log.md entries to keep file small
+// COMPRESS — legacy log.md archiver
 // ═══════════════════════════════════════════════════════════════════
 
 function runCompress(dir) {
@@ -2124,6 +3313,7 @@ function runCompress(dir) {
   write(logPath, header.trimEnd() + '\n' + toKeep.join('') + '\n');
 
   console.log(`\n  memoc compress\n`);
+  console.log('    Legacy command: new activity should use .memoc/worklog/ instead of log.md.');
   console.log(`    Archived  ${toArchive.length} entries → .memoc/log-archive.md`);
   console.log(`    Kept      ${toKeep.length} recent entries in log.md`);
   const saved = Buffer.byteLength(toArchive.join(''), 'utf8');
@@ -2131,6 +3321,91 @@ function runCompress(dir) {
   console.log('\n  Done.\n');
 }
 
+// ═══════════════════════════════════════════════════════════════════
+// TRIM SUMMARY — keep startup memory small and move bulky text aside
+// ═══════════════════════════════════════════════════════════════════
+
+function runTrimSummary(dir) {
+  const summaryPath = path.join(dir, '.memoc', 'session-summary.md');
+  const archivePath = path.join(dir, '.memoc', 'session-summary-archive.md');
+  if (!fs.existsSync(summaryPath)) {
+    write(summaryPath, tplSessionSummary());
+    console.log('\n  memoc trim-summary\n');
+    console.log('    Added .memoc/session-summary.md');
+    console.log('\n  Done.\n');
+    return;
+  }
+
+  const src = fs.readFileSync(summaryPath, 'utf8');
+  const beforeBytes = Buffer.byteLength(src, 'utf8');
+  const compact = compactSessionSummary(src);
+  const afterBytes = Buffer.byteLength(compact, 'utf8');
+
+  if (src === compact && beforeBytes <= 800) {
+    console.log('\n  memoc trim-summary\n');
+    console.log(`    session-summary.md is already compact (${beforeBytes}B).`);
+    console.log('\n  Done.\n');
+    return;
+  }
+
+  const archiveHeader = fs.existsSync(archivePath)
+    ? ''
+    : '# Session Summary Archive\n\nOlder oversized startup summaries moved by `memoc trim-summary`.\n';
+  fs.appendFileSync(archivePath, `${archiveHeader}\n## [${nowISO()}] archived summary (${beforeBytes}B)\n\n${src.trimEnd()}\n`, 'utf8');
+  write(summaryPath, compact);
+
+  console.log('\n  memoc trim-summary\n');
+  console.log(`    Archived  .memoc/session-summary-archive.md`);
+  console.log(`    Rewrote   .memoc/session-summary.md (${beforeBytes}B → ${afterBytes}B)`);
+  console.log('    Reminder  Completed history belongs in worklog; resume details belong in 04-handoff.md.');
+  console.log('\n  Done.\n');
+}
+
+function compactSessionSummary(src) {
+  const sections = ['Status', 'Changed', 'Open Tasks', 'Resume'];
+  const lines = [
+    '# Session Summary',
+    `Last: ${nowISO()}`,
+    'Replace this file instead of appending to it. Keep total size <800B and each section ≤3 bullets.',
+    'Completed history belongs in actor worklogs; incomplete/risky resume detail belongs in `04-handoff.md`.',
+    '',
+  ];
+
+  for (const heading of sections) {
+    lines.push(`## ${heading}`);
+    const bullets = compactSummaryBullets(sectionText(src, heading));
+    if (bullets.length) lines.push(...bullets);
+    else lines.push(summaryPlaceholder(heading));
+    lines.push('');
+  }
+
+  return lines.join('\n').trimEnd() + '\n';
+}
+
+function sectionText(src, heading) {
+  const re = new RegExp(`(?:^|\\n)## ${escapeRegExp(heading)}\\n([\\s\\S]*?)(?=\\n## |$)`);
+  const m = String(src || '').match(re);
+  return m ? m[1].trim() : '';
+}
+
+function compactSummaryBullets(text) {
+  return String(text || '')
+    .split(/\r?\n/)
+    .map(line => line.trim())
+    .filter(line => line && !line.startsWith('#') && !/^_.*_$/.test(line))
+    .map(line => line.replace(/^[-*]\s+/, '').replace(/^\d+[.)]\s+/, '').trim())
+    .filter(Boolean)
+    .slice(0, 3)
+    .map(line => `- ${line.length > 140 ? `${line.slice(0, 137)}...` : line}`);
+}
+
+function summaryPlaceholder(heading) {
+  if (heading === 'Status') return '_Current state in 1-3 bullets._';
+  if (heading === 'Changed') return '_Recent durable changes only._';
+  if (heading === 'Open Tasks') return '_Current open tasks only._';
+  return '_Where the next agent should resume._';
+}
+
 // ═══════════════════════════════════════════════════════════════════
 // SUMMARY
 // ═══════════════════════════════════════════════════════════════════
@@ -2147,7 +3422,7 @@ function runSummary(dir) {
   }
 
   function section(src, heading) {
-    const re = new RegExp(`^## ${heading}\\n([\\s\\S]*?)(?=\\n## |$)`, 'm');
+    const re = new RegExp(`(?:^|\\n)## ${heading}\\n([\\s\\S]*?)(?=\\n## |$)`);
     const m = src.match(re);
     return m ? m[1].trim() : '';
   }
@@ -2205,10 +3480,18 @@ if (!cmd || cmd === '--help' || cmd === '-h' || cmd === 'help') {
   console.log('  upgrade            Refresh memoc runtime/wrappers and managed sections; preserve memory');
   console.log('  summary            Print a tiny status/resume overview');
   console.log('  tokens             Estimate token cost of current memory files');
-  console.log('  compress           Archive old log.md entries to keep file small');
+  console.log('  trim-summary       Archive and compact oversized session-summary.md');
+  console.log('  compress           Legacy: archive old log.md entries');
   console.log('  add <agent>        Add entry file for a specific agent (run without args to list)');
+  console.log('  actor [set <name>] Show or set the local memoc actor');
+  console.log('  work "<title>"     Create a conflict-light actor worklog entry');
+  console.log('  activity           List recent memoc worklog entries');
+  console.log('  doctor             Check common memoc health issues');
   console.log('  search "<query>"   Search memory/agent docs (use --snippets for line matches)');
   console.log('  grep "<query>"     Search project source/text files (use --snippets for line matches)');
+  console.log('  ingest <path|url>  Create a raw/source record scaffold for wiki synthesis');
+  console.log('  note "<title>"     Save a durable topic/query-result scaffold');
+  console.log('  lint-wiki          Check wiki links, tags, backlinks, and Related sections');
   console.log('\nSearch flags:');
   console.log('  --files            Show file names and match counts, sorted by relevance + recency (default)');
   console.log('  --snippets         Show matching lines');
@@ -2224,10 +3507,18 @@ if (cmd === 'update')   { run(cwd, true, 'update');    process.exit(0); }
 if (cmd === 'upgrade')  { run(cwd, true, 'upgrade');   process.exit(0); }
 if (cmd === 'summary')  { runSummary(cwd);    process.exit(0); }
 if (cmd === 'tokens')   { runTokens(cwd);     process.exit(0); }
+if (cmd === 'trim-summary') { runTrimSummary(cwd); process.exit(0); }
 if (cmd === 'compress') { runCompress(cwd);   process.exit(0); }
 if (cmd === 'add')      { runAdd(cwd);        process.exit(0); }
+if (cmd === 'actor')    { runActor(cwd);      process.exit(0); }
+if (cmd === 'work')     { runWork(cwd);       process.exit(0); }
+if (cmd === 'activity') { runActivity(cwd);   process.exit(0); }
+if (cmd === 'doctor')   { runDoctor(cwd);     process.exit(0); }
 if (cmd === 'search')   { runSearch(cwd, 'memory');  process.exit(0); }
 if (cmd === 'grep')     { runSearch(cwd, 'project'); process.exit(0); }
+if (cmd === 'ingest')   { runIngest(cwd);     process.exit(0); }
+if (cmd === 'note')     { runNote(cwd);       process.exit(0); }
+if (cmd === 'lint-wiki') { runWikiLint(cwd);  process.exit(0); }
 
 console.error(`Unknown command: ${cmd}`);
 console.error('Run "memoc --help" for usage.');