@geminilight/mindos 0.5.12 → 0.5.13

package/app/next-env.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="next" />
 /// <reference types="next/image-types/global" />
-import "./.next/dev/types/routes.d.ts";
+import "./.next/types/routes.d.ts";
 
 // NOTE: This file should not be edited
 // see https://nextjs.org/docs/app/api-reference/config/typescript for more information.

package/app/package.json

@@ -13,7 +13,6 @@
   "dependencies": {
     "@ai-sdk/anthropic": "^3.0.58",
     "@ai-sdk/openai": "^3.0.41",
-    "@ai-sdk/react": "^3.0.118",
     "@base-ui/react": "^1.2.0",
     "@codemirror/lang-markdown": "^6.5.0",
     "@codemirror/state": "^6.5.4",

package/bin/lib/build.js

@@ -38,9 +38,13 @@ export function cleanNextDir() {
 }
 
 function depsHash() {
-  const lockPath = resolve(ROOT, 'app', 'package-lock.json');
+  // Use package.json (not package-lock.json) so we don't need to ship the
+  // 560kB lock file in the npm tarball.  package.json changes whenever
+  // dependencies are added/removed/bumped, which is the only case that
+  // requires a fresh `npm install`.
+  const pkgPath = resolve(ROOT, 'app', 'package.json');
   try {
-    const content = readFileSync(lockPath);
+    const content = readFileSync(pkgPath);
     return createHash('sha256').update(content).digest('hex').slice(0, 16);
   } catch {
     return null;

package/bin/lib/sync.js

@@ -1,10 +1,19 @@
-import { execSync } from 'node:child_process';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, mkdirSync, renameSync } from 'node:fs';
 import { resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { CONFIG_PATH, MINDOS_DIR } from './constants.js';
 import { bold, dim, cyan, green, red, yellow } from './colors.js';
 
+// ── Atomic write helper ────────────────────────────────────────────────────
+
+function atomicWriteJSON(filePath, data) {
+  const content = JSON.stringify(data, null, 2) + '\n';
+  const tmp = filePath + '.tmp';
+  writeFileSync(tmp, content, 'utf-8');
+  renameSync(tmp, filePath);
+}
+
 // ── Config helpers ──────────────────────────────────────────────────────────
 
 function loadSyncConfig() {
@@ -20,7 +29,7 @@ function saveSyncConfig(syncConfig) {
   let config = {};
   try { config = JSON.parse(readFileSync(CONFIG_PATH, 'utf-8')); } catch {}
   config.sync = syncConfig;
-  writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  atomicWriteJSON(CONFIG_PATH, config);
 }
 
 function getMindRoot() {
@@ -44,7 +53,7 @@ function loadSyncState() {
 
 function saveSyncState(state) {
   if (!existsSync(MINDOS_DIR)) mkdirSync(MINDOS_DIR, { recursive: true });
-  writeFileSync(SYNC_STATE_PATH, JSON.stringify(state, null, 2) + '\n', 'utf-8');
+  atomicWriteJSON(SYNC_STATE_PATH, state);
 }
 
 // ── Git helpers ─────────────────────────────────────────────────────────────
@@ -53,13 +62,13 @@ function isGitRepo(dir) {
   return existsSync(resolve(dir, '.git'));
 }
 
-function gitExec(cmd, cwd) {
-  return execSync(cmd, { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim();
+function gitExec(args, cwd) {
+  return execFileSync('git', args, { cwd, encoding: 'utf-8', stdio: 'pipe' }).trim();
 }
 
 function getRemoteUrl(cwd) {
   try {
-    return gitExec('git remote get-url origin', cwd);
+    return gitExec(['remote', 'get-url', 'origin'], cwd);
   } catch {
     return null;
   }
@@ -67,7 +76,7 @@ function getRemoteUrl(cwd) {
 
 function getBranch(cwd) {
   try {
-    return gitExec('git rev-parse --abbrev-ref HEAD', cwd);
+    return gitExec(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
   } catch {
     return 'main';
   }
@@ -75,7 +84,7 @@ function getBranch(cwd) {
 
 function getUnpushedCount(cwd) {
   try {
-    return gitExec('git rev-list --count @{u}..HEAD', cwd);
+    return gitExec(['rev-list', '--count', '@{u}..HEAD'], cwd);
   } catch {
     return '?';
   }
@@ -85,12 +94,12 @@ function getUnpushedCount(cwd) {
 
 function autoCommitAndPush(mindRoot) {
   try {
-    execSync('git add -A', { cwd: mindRoot, stdio: 'pipe' });
-    const status = gitExec('git status --porcelain', mindRoot);
+    execFileSync('git', ['add', '-A'], { cwd: mindRoot, stdio: 'pipe' });
+    const status = gitExec(['status', '--porcelain'], mindRoot);
     if (!status) return;
     const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19);
-    execSync(`git commit -m "auto-sync: ${timestamp}"`, { cwd: mindRoot, stdio: 'pipe' });
-    execSync('git push', { cwd: mindRoot, stdio: 'pipe' });
+    execFileSync('git', ['commit', '-m', `auto-sync: ${timestamp}`], { cwd: mindRoot, stdio: 'pipe' });
+    execFileSync('git', ['push', '-u', 'origin', 'HEAD'], { cwd: mindRoot, stdio: 'pipe' });
     saveSyncState({ ...loadSyncState(), lastSync: new Date().toISOString(), lastError: null });
   } catch (err) {
     saveSyncState({ ...loadSyncState(), lastError: err.message, lastErrorTime: new Date().toISOString() });
@@ -99,31 +108,34 @@ function autoCommitAndPush(mindRoot) {
 
 function autoPull(mindRoot) {
   try {
-    execSync('git pull --rebase --autostash', { cwd: mindRoot, stdio: 'pipe' });
+    execFileSync('git', ['pull', '--rebase', '--autostash'], { cwd: mindRoot, stdio: 'pipe' });
     saveSyncState({ ...loadSyncState(), lastPull: new Date().toISOString() });
   } catch {
     // rebase conflict → abort → merge
-    try { execSync('git rebase --abort', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+    try { execFileSync('git', ['rebase', '--abort'], { cwd: mindRoot, stdio: 'pipe' }); } catch {}
     try {
-      execSync('git pull --no-rebase', { cwd: mindRoot, stdio: 'pipe' });
+      execFileSync('git', ['pull', '--no-rebase'], { cwd: mindRoot, stdio: 'pipe' });
       saveSyncState({ ...loadSyncState(), lastPull: new Date().toISOString() });
     } catch {
       // merge conflict → keep both versions
       try {
-        const conflicts = gitExec('git diff --name-only --diff-filter=U', mindRoot).split('\n').filter(Boolean);
+        const conflicts = gitExec(['diff', '--name-only', '--diff-filter=U'], mindRoot).split('\n').filter(Boolean);
+        const conflictWarnings = [];
         for (const file of conflicts) {
           try {
-            const theirs = execSync(`git show :3:${file}`, { cwd: mindRoot, encoding: 'utf-8' });
+            const theirs = execFileSync('git', ['show', `:3:${file}`], { cwd: mindRoot, encoding: 'utf-8' });
             writeFileSync(resolve(mindRoot, file + '.sync-conflict'), theirs, 'utf-8');
-          } catch {}
-          try { execSync(`git checkout --ours "${file}"`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+          } catch {
+            conflictWarnings.push(file);
+          }
+          try { execFileSync('git', ['checkout', '--ours', file], { cwd: mindRoot, stdio: 'pipe' }); } catch {}
         }
-        execSync('git add -A', { cwd: mindRoot, stdio: 'pipe' });
-        execSync('git commit -m "auto-sync: resolved conflicts (kept both versions)"', { cwd: mindRoot, stdio: 'pipe' });
+        execFileSync('git', ['add', '-A'], { cwd: mindRoot, stdio: 'pipe' });
+        execFileSync('git', ['commit', '-m', 'auto-sync: resolved conflicts (kept both versions)'], { cwd: mindRoot, stdio: 'pipe' });
         saveSyncState({
           ...loadSyncState(),
           lastPull: new Date().toISOString(),
-          conflicts: conflicts.map(f => ({ file: f, time: new Date().toISOString() })),
+          conflicts: conflicts.map(f => ({ file: f, time: new Date().toISOString(), noBackup: conflictWarnings.includes(f) })),
         });
       } catch (err) {
         saveSyncState({ ...loadSyncState(), lastError: err.message, lastErrorTime: new Date().toISOString() });
@@ -133,9 +145,9 @@ function autoPull(mindRoot) {
 
   // Retry any pending pushes (handles previous push failures)
   try {
-    const unpushed = gitExec('git rev-list --count @{u}..HEAD', mindRoot);
+    const unpushed = gitExec(['rev-list', '--count', '@{u}..HEAD'], mindRoot);
     if (parseInt(unpushed) > 0) {
-      execSync('git push', { cwd: mindRoot, stdio: 'pipe' });
+      execFileSync('git', ['push'], { cwd: mindRoot, stdio: 'pipe' });
       saveSyncState({ ...loadSyncState(), lastSync: new Date().toISOString(), lastError: null });
     }
   } catch {
@@ -196,8 +208,8 @@ export async function initSync(mindRoot, opts = {}) {
   // 1. Ensure git repo
   if (!isGitRepo(mindRoot)) {
     if (!nonInteractive) console.log(dim('Initializing git repository...'));
-    execSync('git init', { cwd: mindRoot, stdio: 'pipe' });
-    try { execSync('git checkout -b main', { cwd: mindRoot, stdio: 'pipe' }); } catch {}
+    execFileSync('git', ['init'], { cwd: mindRoot, stdio: 'pipe' });
+    try { execFileSync('git', ['checkout', '-b', 'main'], { cwd: mindRoot, stdio: 'pipe' }); } catch {}
   }
 
   // 1b. Ensure .gitignore exists
@@ -226,35 +238,61 @@ export async function initSync(mindRoot, opts = {}) {
     if (platform === 'darwin') helper = 'osxkeychain';
     else if (platform === 'win32') helper = 'manager';
     else helper = 'store';
-    try { execSync(`git config credential.helper '${helper}'`, { cwd: mindRoot, stdio: 'pipe' }); } catch {}
-    // Store the credential via git credential approve
+    try { execFileSync('git', ['config', 'credential.helper', helper], { cwd: mindRoot, stdio: 'pipe' }); } catch (e) {
+      console.error(`[sync] credential.helper setup failed: ${e.message}`);
+    }
+    // Store the credential via git credential approve, then verify it stuck
+    let credentialStored = false;
     try {
       const credInput = `protocol=${urlObj.protocol.replace(':', '')}\nhost=${urlObj.host}\nusername=oauth2\npassword=${token}\n\n`;
-      execSync('git credential approve', { cwd: mindRoot, input: credInput, stdio: 'pipe' });
-    } catch {}
+      execFileSync('git', ['credential', 'approve'], { cwd: mindRoot, input: credInput, stdio: 'pipe' });
+      // Verify: credential fill should return the password we just stored
+      try {
+        const fillInput = `protocol=${urlObj.protocol.replace(':', '')}\nhost=${urlObj.host}\nusername=oauth2\n\n`;
+        const fillResult = execFileSync('git', ['credential', 'fill'], {
+          cwd: mindRoot, input: fillInput, encoding: 'utf-8',
+          stdio: ['pipe', 'pipe', 'pipe'], timeout: 5000,
+          env: { ...process.env, GIT_TERMINAL_PROMPT: '0' },
+        });
+        credentialStored = fillResult.includes(`password=${token}`);
+      } catch {
+        credentialStored = false;
+      }
+    } catch (e) {
+      if (!nonInteractive) console.error(`[sync] credential approve failed: ${e.message}`);
+    }
+    // If credential helper didn't actually persist, embed token in URL
+    if (!credentialStored) {
+      if (!nonInteractive) console.log(dim('Credential helper unavailable, using inline token'));
+      const fallbackUrl = new URL(remoteUrl);
+      fallbackUrl.username = 'oauth2';
+      fallbackUrl.password = token;
+      remoteUrl = fallbackUrl.toString();
+    }
     // For 'store' helper, restrict file permissions AFTER credential file is created
     if (helper === 'store') {
       const credFile = resolve(process.env.HOME || homedir(), '.git-credentials');
-      try { execSync(`chmod 600 "${credFile}"`, { stdio: 'pipe' }); } catch {}
+      try { execFileSync('chmod', ['600', credFile], { stdio: 'pipe' }); } catch {}
     }
   }
 
   // 4. Set remote
   try {
-    execSync(`git remote add origin "${remoteUrl}"`, { cwd: mindRoot, stdio: 'pipe' });
+    execFileSync('git', ['remote', 'add', 'origin', remoteUrl], { cwd: mindRoot, stdio: 'pipe' });
   } catch {
-    execSync(`git remote set-url origin "${remoteUrl}"`, { cwd: mindRoot, stdio: 'pipe' });
+    execFileSync('git', ['remote', 'set-url', 'origin', remoteUrl], { cwd: mindRoot, stdio: 'pipe' });
   }
 
   // 5. Test connection
   if (!nonInteractive) console.log(dim('Testing connection...'));
   try {
-    execSync('git ls-remote --exit-code origin', { cwd: mindRoot, stdio: 'pipe', timeout: 15000 });
+    execFileSync('git', ['ls-remote', '--exit-code', 'origin'], { cwd: mindRoot, stdio: 'pipe', timeout: 15000 });
     if (!nonInteractive) console.log(green('✔ Connection successful'));
-  } catch {
-    const errMsg = 'Remote not reachable — check URL and credentials';
+  } catch (lsErr) {
+    const detail = lsErr.stderr ? lsErr.stderr.toString().trim() : '';
+    const errMsg = `Remote not reachable${detail ? ': ' + detail : ''} — check URL and credentials`;
     if (nonInteractive) throw new Error(errMsg);
-    console.error(red('✘ Could not connect to remote. Check your URL and credentials.'));
+    console.error(red(`✘ ${errMsg}`));
     process.exit(1);
   }
 
@@ -272,11 +310,11 @@ export async function initSync(mindRoot, opts = {}) {
 
   // 7. First sync: pull if remote has content, push otherwise
   try {
-    const refs = gitExec('git ls-remote --heads origin', mindRoot);
+    const refs = gitExec(['ls-remote', '--heads', 'origin'], mindRoot);
     if (refs) {
       if (!nonInteractive) console.log(dim('Pulling from remote...'));
       try {
-        execSync(`git pull origin ${syncConfig.branch} --allow-unrelated-histories`, { cwd: mindRoot, stdio: nonInteractive ? 'pipe' : 'inherit' });
+        execFileSync('git', ['pull', 'origin', syncConfig.branch, '--allow-unrelated-histories'], { cwd: mindRoot, stdio: nonInteractive ? 'pipe' : 'inherit' });
       } catch {
         if (!nonInteractive) console.log(yellow('Pull completed with warnings. Check for conflicts.'));
       }
@@ -321,7 +359,10 @@ export async function startSyncDaemon(mindRoot) {
   autoPull(mindRoot);
 
   // Graceful shutdown: flush pending changes before exit
+  let shutdownInProgress = false;
   const gracefulShutdown = () => {
+    if (shutdownInProgress) return;
+    shutdownInProgress = true;
     if (commitTimer) { clearTimeout(commitTimer); commitTimer = null; }
     try { autoCommitAndPush(mindRoot); } catch {}
     stopSyncDaemon();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geminilight/mindos",
-  "version": "0.5.12",
+  "version": "0.5.13",
   "description": "MindOS — Human-Agent Collaborative Mind System. Local-first knowledge base that syncs your mind to all AI Agents via MCP.",
   "keywords": [
     "mindos",
@@ -57,7 +57,8 @@
     "!assets/images",
     "!mcp/node_modules",
     "!mcp/dist",
-    "!mcp/package-lock.json"
+    "!mcp/package-lock.json",
+    "!app/package-lock.json"
   ],
   "scripts": {
     "setup": "node scripts/setup.js",

package/scripts/setup.js

@@ -1225,6 +1225,11 @@ function getLocalIP() {
 }
 
 async function finish(mindDir, startMode = 'start', mcpPort = 8781, authToken = '', installDaemon = false, needsRestart = false, oldPort = 3456) {
+  // startMode 'daemon' stored in config is equivalent to installDaemon flag
+  if (startMode === 'daemon') {
+    installDaemon = true;
+    startMode = 'start';
+  }
   if (needsRestart) {
     const isRunning = await isSelfPort(oldPort);
     if (isRunning) {

package/skills/mindos/SKILL.md

@@ -110,172 +110,52 @@ Before any non-trivial write, confirm all checks:
 
 ## Execution Patterns
 
-### Capture or update notes
-
-1. Search existing docs.
-2. Read target docs and local rules.
-3. Apply minimal edit.
-4. Keep references consistent when paths change.
-
-### Distill cross-agent discussion
-
-1. Ask user to confirm key decisions and conclusions.
-2. Locate destination docs.
-3. Structure content as problem, decision, rationale, caveats, next actions.
-4. Write back with minimal invasive edits.
-
-Never imply access to private history from other agent sessions.
-
-### Conversation retrospective and adaptive updates
-
-1. Ask the user to confirm retrospective objective and scope for this conversation.
-2. Extract reusable artifacts: decisions, rationale, pitfalls, unresolved questions, and next actions.
-3. Route each artifact to the most appropriate existing file by searching and reading candidate docs.
-4. If a matching file exists, update minimally at section/line level; if not, create a well-scoped new file near related docs.
-5. Keep references/backlinks consistent and add a short trace note of what changed and why.
-6. If confidence in file routing is low, present 1-2 candidate destinations and ask user to choose before writing.
-
-### Execute or update workflow/SOP docs
-
-1. Read workflow doc fully.
-2. Execute stepwise and record outcomes.
-3. If outdated, update only affected section and include rationale.
-
-### CSV operations
-
-1. Read header.
-2. Validate field order, count, and type.
-3. Append one row.
-
-### Information collection and outreach
-
-1. Locate authoritative contact/list sources.
-2. Read relevant outreach/execution workflow docs.
-3. Generate personalized outputs per target using profile tags, domain, and tone.
-4. Write outcomes and next actions back for traceability.
-
-### Project bootstrap with personal/team standards
-
-1. Read preference/context docs such as stack, style, and constraints.
-2. Read startup/engineering workflow docs.
-3. Produce initial scaffold/configuration aligned with those standards.
-4. Record key decisions and setup status for future handoff.
-
-### Standards-aligned code review
-
-1. Read applicable review and engineering standards.
-2. Review naming, error handling, performance, security, and maintainability.
-3. Output actionable findings with concrete file-level suggestions.
-4. Keep tone and structure consistent with team review style.
-
-### Cross-agent handoff continuity
-
-1. Treat the shared knowledge base as handoff contract.
-2. Before continuing work, read task state, decisions, and pending items.
-3. Continue without re-discovery and preserve conventions/rationale.
-4. Write back progress so later sessions can resume immediately.
-
-### Relationship and follow-up management
-
-1. Extract factual updates, intent, and sentiment from user-provided conversation notes.
-2. Update relationship/contact records in structured form.
-3. Generate next-step strategy, todo items, and suggested follow-up timing.
-4. Store updates in reusable format for future session continuity.
-
-### Structure-aware multi-file routing
-
-A single unstructured input (chat export, meeting notes, voice transcript, braindump) often contains information that belongs in multiple places. MindOS knows the full directory tree and inter-document relationships from bootstrap, so it can decompose the input and route each piece to the right file — in one pass, without the user manually specifying destinations.
-
-1. Load structure context via `mindos_bootstrap` and `mindos_list_files` to understand the full knowledge topology.
-2. Parse the input into distinct semantic units (facts, decisions, ideas, action items, relationship updates, new concepts).
-3. For each unit, search and read candidate destination files to find the best match by topic, scope, and existing structure.
-4. **Before writing, present the routing plan to the user for approval.** Show a clear summary table: what will be written, to which file, at which location. Only proceed after user confirms.
-5. Apply minimal edits to each target file at the correct location (section, heading, or line level). Create new files only when no existing file is a reasonable fit.
-6. If routing confidence is low for any unit, present candidate destinations and ask the user to choose.
-7. After all writes, summarize what changed and where, so the user can audit the full update in one glance.
-
-This pattern is what makes MindOS fundamentally different from document-per-document tools: the structural prior means one input triggers coordinated updates across the knowledge base, and nothing falls through the cracks because the agent sees the whole graph.
-
-### Knowledge conflict resolution
-
-When a decision, preference, or fact changes (e.g., "we switched from Redis to Memcached"), all documents referencing the old information must be updated consistently.
-
-1. Search the entire knowledge base for references to the outdated information (use multiple search terms, including abbreviations and variants).
-2. List all affected files and the specific lines/sections that reference the old decision.
-3. Present the full change plan to the user: which files, what will change, and why.
-4. After approval, update each file with minimal targeted edits.
-5. Verify no inconsistent references remain after the update.
-
-### Distill experience into new SOP
-
-When the user has just completed a complex task and wants to capture the process for reuse, create a structured, reusable workflow document — not just a one-time record.
-
-1. Extract the procedure, decision points, prerequisites, and common pitfalls from the user's description.
-2. Generalize: remove one-off specifics, keep the reusable pattern.
-3. Find the appropriate location under Workflows/ or a similar directory. Check for existing SOP templates or sibling format.
-4. Create the SOP with clear sections: prerequisites, step-by-step procedure, troubleshooting/pitfalls, and references to related docs.
-5. Link the new SOP from relevant index files if applicable.
-
-### Periodic review and summary
-
-When the user asks for a weekly review, monthly recap, or progress summary:
-
-1. Use `mindos_get_recent` and/or `mindos_get_history` to identify files changed in the relevant time window.
-2. Read changed files to understand what happened.
-3. Categorize changes by area (projects, profile, workflows, etc.).
-4. Produce a structured summary: key decisions made, progress on active projects, open items, and things that need attention.
-5. Offer to write the summary back as a review note if the user wants to keep it.
-
-### Context-aware question answering
-
-When the user asks a question about themselves, their projects, preferences, or stored knowledge:
-
-1. Reason from the directory tree to identify which files likely contain the answer.
-2. Read the relevant files — do not guess or assume from general knowledge.
-3. Answer grounded in actual stored content, citing source files.
-4. If the information is incomplete or missing, say so explicitly rather than fabricating.
-
-### TODO and task list management
-
-When the user wants to add, complete, or modify tasks:
-
-1. Locate the TODO file or task list (search or navigate from directory structure).
-2. Read current content to understand existing format (checkboxes, priorities, categories).
-3. Make minimal targeted edits: mark items, add items, or update status.
-4. Preserve all other existing content and formatting.
-5. Follow the existing format conventions exactly — do not introduce a new task format.
-
-### Handoff document synthesis
-
-When the user needs to create a handoff or briefing document for someone else (new team member, collaborator, manager):
-
-1. Identify all relevant source files across the knowledge base for the topic (project docs, decisions, status, tech stack, open items).
-2. Read each source file to extract the relevant information.
-3. Synthesize into a single coherent handoff document with sections: background, key decisions and rationale, current status, open items, and further reading (with links to source files).
-4. Place the handoff document in the appropriate project directory, not the root.
-
-### Structural rename and move
-
-When renaming or moving files/directories:
-
-1. Use `mindos_get_backlinks` to find all files referencing the target path.
-2. Report the full impact scope to the user: how many files, which ones, what references.
-3. Ask for confirmation before proceeding.
-4. Execute the rename/move.
-5. Update all broken references in affected files.
-6. Verify no orphaned links remain.
-
-### Auto-sync READMEs after directory changes
-
-After any operation that affects directory structure (creating, deleting, moving, or renaming files or subdirectories):
-
-1. Identify affected directories: the directory where the file was (source), the directory where it now is (destination), and their parent directories.
-2. Read the README in each affected directory (if one exists).
-3. Update file listings, indexes, and navigation in each README to accurately reflect the current directory contents.
-4. If the README contains file descriptions or links, update paths and names accordingly.
-5. If a directory has no README but sibling directories generally do, consider creating one for the new directory.
-
-This step is an automatic follow-up to all structural change operations — it does not require a separate user request.
+Select the matching pattern below. All patterns share a common discipline: search → read → minimal edit → verify → summarize.
+
+### Core patterns (high-frequency)
+
+#### Capture or update notes
+Search → read target + local rules → apply minimal edit → keep references consistent.
+
+#### Context-aware question answering
+Reason from directory tree → read relevant files → answer grounded in stored content with file citations → if info is missing, say so explicitly.
+
+#### Structure-aware multi-file routing
+For unstructured inputs (meeting notes, braindumps, chat exports) that belong in multiple places:
+1. Parse input into semantic units (facts, decisions, action items, ideas).
+2. For each unit, search + read candidate destination files.
+3. **Present routing plan to user for approval** (table: what → which file → where).
+4. Apply minimal edits. Create new files only when no existing file fits.
+5. Summarize all changes for audit.
+
+#### Conversation retrospective
+1. Confirm scope with user.
+2. Extract reusable artifacts: decisions, rationale, pitfalls, next actions.
+3. Route each to the best existing file (or create near related docs).
+4. Add trace note of what changed and why. Ask user when routing confidence is low.
+
+### Structural change patterns (always apply after file create/delete/move/rename)
+
+- **Rename/move**: `get_backlinks` → report impact → confirm → execute → update all references → verify no orphans.
+- **Auto-sync READMEs**: After any structural change, update README in affected directories + parent directories to reflect current contents. This is automatic — no separate user request needed.
+
+### Reference patterns (use when task matches)
+
+| Pattern | Key steps |
+|---------|-----------|
+| CSV operations | Read header → validate fields → append row |
+| TODO/task management | Locate list → read format → minimal edit preserving conventions |
+| SOP/workflow execution | Read doc fully → execute stepwise → update only affected section |
+| Cross-agent handoff | Read task state + decisions → continue without re-discovery → write back progress |
+| Knowledge conflict resolution | Multi-term search for old info → list all affected files → present change plan → update after approval |
+| Distill experience into SOP | Extract procedure → generalize → create under Workflows/ with prerequisites, steps, pitfalls |
+| Periodic review/summary | `get_recent`/`get_history` → read changed files → categorize → structured summary |
+| Handoff document synthesis | Identify sources → read → synthesize (background, decisions, status, open items) → place in project dir |
+| Relationship management | Extract updates from notes → update contact records → generate next-step strategy |
+| Information collection | Locate sources → read outreach docs → personalize per target → write back outcomes |
+| Project bootstrap | Read preference/stack docs → scaffold aligned with standards → record decisions |
+| Code review | Read review standards → check naming/security/performance → output actionable findings |
+| Distill cross-agent discussion | Confirm decisions with user → structure as problem/decision/rationale/next-actions → minimal write-back |
 
 ## Interaction Rules
 
@@ -293,28 +173,12 @@ This step is an automatic follow-up to all structural change operations — it d
 - Never store secrets, tokens, or passwords.
 - Never delete or rewrite outside user intent.
 
-## Continuous Evaluation Loop
-
-For important workflows, run a fast iterate loop:
-
-1. Define 2-3 representative prompts for the current task type.
-2. Run the workflow with this skill guidance.
-3. Check result quality against user intent, local conventions, and safety rules.
-4. Identify the smallest instruction change that would prevent observed failure modes.
-5. Re-run prompts and keep only changes that improve consistency without overfitting.
-
 ## Quality Gates
 
-Before finishing, verify:
+Before finishing any operation, verify:
 
 1. Result directly answers user intent.
 2. Updated content matches local style and structure.
 3. References/links remain valid after structural edits.
 4. No sensitive information was introduced.
 5. Summary to user is specific enough for quick audit.
-
-## Style Rules
-
-- Follow repository-local style.
-- Keep language concise and execution-oriented.
-- Preserve useful structure like headings, checklists, tables, and references.