total-recall-brain 3.45.0 → 3.46.0

package/scaffold/.agent/skills/total-recall/plugins/git/src/ops/fleet.mjs

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { failure, gitText, output, trJson } from './_support.mjs';
+import { inspectUnmerged } from './unmerged.mjs';
 
 const STALE_MS = 30 * 24 * 60 * 60 * 1000;
 
@@ -23,15 +24,27 @@ export function registeredRepositories(ctx) {
   return fallback;
 }
 
+/**
+ * A registered brain need not be a git repository (personal workspace brains,
+ * plain folders); that is not a failure. A registered path that is gone is.
+ */
+export function registeredPathState(directory, ctx) {
+  if (!existsSync(directory)) return 'missing';
+  const inside = ctx.git(['-C', directory, 'rev-parse', '--is-inside-work-tree']);
+  return inside.status === 0 && String(inside.stdout).trim() === 'true' ? 'repository' : 'not-a-repository';
+}
+
 export function inspectRepository(directory, ctx, now = Date.now()) {
   const local = { ...ctx, git: (args, options) => ctx.git(['-C', directory, ...args], options) };
   const errors = [];
   const report = { path: directory, dirty: null, unpushed: null, behind: null, diverged: null,
-    staleStashes: null, abandonedWorktrees: null, upstream: null, errors };
+    staleStashes: null, abandonedWorktrees: null, unmerged: null, upstream: null, errors };
   const get = args => {
     try { return gitText(local, args); } catch { errors.push(args[0]); return null; }
   };
-  if (get(['rev-parse', '--is-inside-work-tree'])?.trim() !== 'true') return { ...report, error: 'Repository is unavailable' };
+  const state = registeredPathState(directory, ctx);
+  if (state === 'missing') return { ...report, error: 'Registered path does not exist' };
+  if (state === 'not-a-repository') return { ...report, notRepository: true };
   const status = get(['status', '--porcelain=v1', '-z']);
   if (status !== null) report.dirty = status.length > 0;
   const upstream = local.git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{upstream}']);
@@ -63,6 +76,11 @@ export function inspectRepository(directory, ctx, now = Date.now()) {
     return !state.stdout && Number(last.stdout.trim()) * 1000 < now - STALE_MS
       ? [{ path: fields.worktree, reason: 'clean-with-old-head', candidate: true }] : [];
   });
+  // Branches and worktrees holding work the default branch lacks (unmerged.mjs owns the rule).
+  try {
+    const unmerged = inspectUnmerged(directory, ctx);
+    if (unmerged.error) errors.push('unmerged'); else report.unmerged = unmerged.outstanding;
+  } catch { errors.push('unmerged'); }
   return report;
 }
 
@@ -90,7 +108,7 @@ function localReport(ctx, commit) {
       if (commit) {
         const contains = ctx.git(['-C', directory, 'cat-file', '-e', `${commit}^{commit}`]);
         if (contains.status !== 0) {
-          if (ctx.git(['-C', directory, 'rev-parse', '--git-dir']).status !== 0) errors.push({ path: directory, error: 'Repository is unavailable' });
+          if (registeredPathState(directory, ctx) === 'missing') errors.push({ path: directory, error: 'Registered path does not exist' });
           continue;
         }
         repositories.push(containingCheckouts(directory, commit, ctx));
@@ -141,9 +159,9 @@ async function run(args, ctx, where = false) {
     if (args.includes('--all-nodes') || where && !args.includes('--local')) nodes.push(...remoteReports(ctx, commit));
     const ok = nodes.every(node => !node.errors?.length);
     const result = { ok, ...(where ? { commit } : {}), nodes };
-    const lines = nodes.flatMap(node => [node.node, ...node.repositories.map(repo => where
+    const lines = nodes.flatMap(node => [node.node, ...node.repositories.map(repo => repo.notRepository ? `  ${repo.path}: not a git repository` : where
       ? `  ${repo.path}: ${repo.checkouts.length} checkouts; ${repo.refs.length} refs`
-      : `  ${repo.path}: dirty=${repo.dirty ?? 'unknown'} unpushed=${repo.unpushed ?? 'unknown'} behind=${repo.behind ?? 'unknown'} diverged=${repo.diverged ?? 'unknown'} stale-stashes=${repo.staleStashes?.length ?? 'unknown'} abandoned-worktrees=${repo.abandonedWorktrees?.length ?? 'unknown'}`),
+      : `  ${repo.path}: dirty=${repo.dirty ?? 'unknown'} unpushed=${repo.unpushed ?? 'unknown'} behind=${repo.behind ?? 'unknown'} diverged=${repo.diverged ?? 'unknown'} stale-stashes=${repo.staleStashes?.length ?? 'unknown'} abandoned-worktrees=${repo.abandonedWorktrees?.length ?? 'unknown'} unmerged=${repo.unmerged ?? 'unknown'}`),
     ...(node.errors || []).map(e => `  unavailable: ${e.path || node.node}`)]);
     output(ctx, result, lines.join('\n'));
     return ok ? 0 : 1;
@@ -151,6 +169,6 @@ async function run(args, ctx, where = false) {
 }
 
 export const operations = {
-  fleet: { summary: 'Report repository state on this node or every mesh node', usage: 'fleet [--all-nodes] [--json]', run: (args, ctx) => run(args, ctx) },
+  fleet: { summary: 'Report repository state (including unmerged branches and worktrees) on this node or every mesh node', usage: 'fleet [--all-nodes] [--json]', run: (args, ctx) => run(args, ctx) },
   where: { summary: 'Find machines and checkouts that contain a commit', usage: 'where <commit> [--local] [--json]', run: (args, ctx) => run(args, ctx, true) },
 };

package/scaffold/.agent/skills/total-recall/plugins/git/src/ops/secret-firewall.mjs

@@ -9,12 +9,37 @@ export function scanText(ctx, text) {
   const result = spawnSync(ctx.env?.GIT_PLUGIN_TR_BIN || 'total-recall', ['auth', 'secret', 'scan', '--stdin', '--json'], {
     cwd: ctx.cwd, env: ctx.env, input: text, encoding: 'utf8', shell: false, timeout: 120000, maxBuffer: 16 * 1024 * 1024,
   });
-  if (result.error || ![0, 1].includes(result.status)) throw new Error('Auth secret scan failed');
-  const reply = JSON.parse(result.stdout);
-  if (!Array.isArray(reply.keys)) throw new Error('Auth secret scan returned no key list');
+  if (result.error) throw new Error(`auth secret scan could not start (${result.error.code || 'spawn failed'})`);
+  if (result.signal) throw new Error(`auth secret scan was stopped (${result.signal})`);
+  let reply = null;
+  try { reply = JSON.parse(result.stdout); } catch { /* named below; a parse error can quote the output */ }
+  if (![0, 1].includes(result.status) || !reply) throw new Error(scanFailure(result));
+  if (!Array.isArray(reply.keys)) throw new Error('auth secret scan returned no key list');
   return reply.keys;
 }
 
+/**
+ * Name why the scan gave no result without forwarding the child's output,
+ * which can hold credential material. A generic "could not complete" hid that
+ * auth was simply turned off for the repository (2026-11-12).
+ */
+function scanFailure(result) {
+  const stderr = String(result.stderr || '');
+  if (/Plugin auth is inactive/.test(stderr)) return 'the auth plugin is turned off for this repository; run total-recall plugin on auth';
+  if (/Unknown (plugin|command)|not installed/i.test(stderr)) return 'the auth plugin is not installed here or has no secret scan';
+  return `auth secret scan exited ${result.status} without a result`;
+}
+
+/**
+ * The publishable part of a patch: everything except removed lines. A removed line is content the
+ * commit takes out; scanning it blocked the very commit that redacts a secret already in history
+ * (a project tracker, 2026-11-12). Added lines, headers, binary patches and the commit message
+ * are still scanned, and every staged or outgoing blob is scanned whole.
+ */
+export function publishedPatchText(patch) {
+  return String(patch).split('\n').filter((line) => !(line.startsWith('-') && !line.startsWith('---'))).join('\n');
+}
+
 export function checkSecrets(args, ctx) {
   const call = invocation(args, ctx);
   if (!['commit', 'push'].includes(call.command) || helpOnly(args)) return;
@@ -25,7 +50,7 @@ export function checkSecrets(args, ctx) {
     const chunks = [];
     const add = value => chunks.push(Buffer.isBuffer(value) ? value.toString('utf8') : value);
     if (call.command === 'commit') {
-      add(gitText(call.ctx, ['diff', '--cached', '--no-ext-diff', '--no-textconv', '--binary', '--']));
+      add(publishedPatchText(gitText(call.ctx, ['diff', '--cached', '--no-ext-diff', '--no-textconv', '--binary', '--'])));
       const paths = gitText(call.ctx, ['diff', '--cached', '--name-only', '--diff-filter=ACMRT', '-z', '--']).split('\0').filter(Boolean);
       for (const file of paths) {
         const row = call.ctx.git(['show', `:${file}`], { encoding: null });
@@ -35,7 +60,7 @@ export function checkSecrets(args, ctx) {
     } else {
       const scanned = new Set();
       for (const commit of outgoingCommits(call.ctx, call.args)) {
-        add(gitText(call.ctx, ['show', '--format=fuller', '--root', '--no-ext-diff', '--no-textconv', '--binary', commit, '--']));
+        add(publishedPatchText(gitText(call.ctx, ['show', '--format=fuller', '--root', '--no-ext-diff', '--no-textconv', '--binary', commit, '--'])));
         // Raw blobs of the files this commit changed: a binary patch does not contain the original bytes.
         const changed = gitText(call.ctx, ['diff-tree', '-r', '-z', '--root', '--no-commit-id', commit]).split('\0').filter(Boolean);
         for (const entry of changed) {
@@ -58,8 +83,9 @@ export function checkSecrets(args, ctx) {
     }
     flush();
     if (matches.size) return { refuse: `Auth secret match: ${[...matches].sort().join(', ')}` };
-  } catch {
-    return { refuse: 'Secret firewall could not complete. Check auth store and repository access.' };
+  } catch (error) {
+    // Our own messages only: git failures and scanFailure never carry file or secret content.
+    return { refuse: `Secret firewall could not complete: ${error.message}. Check auth store and repository access.` };
   } finally { prospective?.cleanup(); }
 }
 

package/scaffold/.agent/skills/total-recall/plugins/git/src/ops/undo.mjs

@@ -38,6 +38,23 @@ function untrackedSnapshot(ctx, includeIgnored) {
   } finally { rmSync(dir, { recursive: true, force: true }); }
 }
 
+/**
+ * Tracked working-tree content as a commit on HEAD, through a private index. `git stash create`
+ * refuses while the index has unmerged paths, which blocked every conflict resolution
+ * (`checkout --theirs -- <file>`) with "Cannot save an undo snapshot". This keeps the content;
+ * an undo restores the files, not the merge state itself.
+ */
+function trackedSnapshot(ctx) {
+  const dir = mkdtempSync(path.join(os.tmpdir(), 'git-undo-tracked-'));
+  const env = { ...objectEnv(ctx), GIT_INDEX_FILE: path.join(dir, 'index') };
+  try {
+    gitText(ctx, ['read-tree', 'HEAD'], { env });
+    gitText(ctx, ['add', '--update', '--', '.'], { env });
+    const tree = gitText(ctx, ['write-tree'], { env }).trim();
+    return gitText(ctx, ['commit-tree', tree, '-p', 'HEAD', '-m', 'Git undo working tree'], { env }).trim();
+  } finally { rmSync(dir, { recursive: true, force: true }); }
+}
+
 export async function snapshot(ctx, command, { includeIgnored = false } = {}) {
   const store = await stateStore(ctx);
   const repository = repoId(ctx);
@@ -52,17 +69,24 @@ export async function snapshot(ctx, command, { includeIgnored = false } = {}) {
   const head = gitText(ctx, ['rev-parse', '--verify', 'HEAD']).trim();
   const sym = ctx.git(['symbolic-ref', '-q', 'HEAD']);
   const status = gitText(ctx, ['status', '--porcelain=v1', '-z']);
-  const stash = status ? gitText(ctx, ['stash', 'create'], { env: objectEnv(ctx) }).trim() || null : null;
+  let stash = null, tracked = null;
+  if (status) {
+    const created = ctx.git(['stash', 'create'], { env: objectEnv(ctx) });
+    if (!created.error && created.status === 0) stash = String(created.stdout).trim() || null;
+    // Only a conflicted index makes stash create refuse for a reason a content snapshot answers.
+    else if (gitText(ctx, ['ls-files', '--unmerged']).trim()) tracked = trackedSnapshot(ctx);
+    else throw new Error('git stash create failed');
+  }
   const untracked = untrackedSnapshot(ctx, includeIgnored);
   const stashes = gitText(ctx, ['stash', 'list', '--format=%H%x00%gs']).trim().split('\n').filter(Boolean).map(row => {
     const [oid, message] = row.split('\0'); return { oid, message };
   });
-  const objects = [...new Set([head, stash, untracked, ...refs.map(r => r.oid), ...stashes.map(r => r.oid)].filter(Boolean))];
+  const objects = [...new Set([head, stash, tracked, untracked, ...refs.map(r => r.oid), ...stashes.map(r => r.oid)].filter(Boolean))];
   // Pin objects before the event is durable. Git GC must not remove a snapshot.
   for (let i = 0; i < objects.length; i += 1) gitText(ctx, ['update-ref', `${backupPrefix}${id}/${i}`, objects[i]]);
   const event = { id, type: 'git.snapshot', timestamp: new Date().toISOString(), repository, worktree,
     command: [command[0]], refs, head, symbolicHead: sym.status === 0 ? sym.stdout.trim() : null,
-    stash, untracked, stashes, includeIgnored };
+    stash, tracked, untracked, stashes, includeIgnored };
   store.append(event);
   return event;
 }
@@ -92,11 +116,11 @@ async function restore(ctx, event) {
   else gitText(ctx, ['update-ref', '--no-deref', 'HEAD', event.head]);
   gitText(ctx, ['reset', '--hard', event.head]);
   if (event.stash) gitText(ctx, ['stash', 'apply', '--index', event.stash]);
-  if (event.untracked) {
+  for (const commit of [event.tracked, event.untracked].filter(Boolean)) {
     const dir = mkdtempSync(path.join(os.tmpdir(), 'git-undo-restore-'));
     const env = { ...ctx.env, GIT_INDEX_FILE: path.join(dir, 'index') };
     try {
-      gitText(ctx, ['read-tree', event.untracked], { env });
+      gitText(ctx, ['read-tree', commit], { env });
       gitText(ctx, ['checkout-index', '--all', '--force'], { env });
     } finally { rmSync(dir, { recursive: true, force: true }); }
   }

package/scaffold/.agent/skills/total-recall/plugins/git/src/ops/unmerged.mjs

@@ -0,0 +1,182 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { failure, gitText, output } from './_support.mjs';
+import { registeredPathState, registeredRepositories } from './fleet.mjs';
+
+/**
+ * Work that never reached the default branch: local branches with commits the
+ * default branch does not contain, linked worktrees with uncommitted changes,
+ * and detached worktrees holding commits no branch contains (removing such a
+ * worktree loses them).
+ *
+ * Nothing reported this before. A week of drawer UI work sat on an unpushed
+ * branch with 256 uncommitted files in a worktree, and about 35 plugin
+ * worktrees sat beside it, while every status said the repositories were fine.
+ *
+ * A commit counts as landed when the default branch (local or origin) reaches
+ * it, or holds an equivalent patch (`git cherry`), so rebased and
+ * cherry-picked work is not reported. A squash merge is a different patch and
+ * still shows; delete the branch once it has landed. A branch the operator
+ * keeps on purpose (`git config --add totalrecall.keepBranch <name>`) is
+ * listed as kept and not counted.
+ */
+
+const SUMMARY_LIMIT = 480;
+
+function localCtx(ctx, directory) {
+  return { ...ctx, git: (args, options) => ctx.git(['-C', directory, ...args], options) };
+}
+
+const refExists = (local, ref) => local.git(['rev-parse', '--verify', '--quiet', `${ref}^{commit}`]).status === 0;
+
+/** The default branch: origin's HEAD, else local main or master, else init.defaultBranch. */
+export function defaultBranch(local) {
+  const originHead = local.git(['symbolic-ref', '--quiet', 'refs/remotes/origin/HEAD']);
+  const fromOrigin = originHead.status === 0 ? originHead.stdout.trim().replace(/^refs\/remotes\/origin\//, '') : null;
+  const configured = local.git(['config', '--get', 'init.defaultBranch']);
+  const candidates = [fromOrigin, 'main', 'master', configured.status === 0 ? configured.stdout.trim() : null].filter(Boolean);
+  for (const name of candidates) {
+    const localRef = `refs/heads/${name}`, remoteRef = `refs/remotes/origin/${name}`;
+    const refs = [localRef, remoteRef].filter(ref => refExists(local, ref));
+    if (refs.length) return { name, refs };
+  }
+  return null;
+}
+
+/** Non-merge commits on `tip` that no default ref reaches and whose patch the default branch lacks. */
+function uniqueCommits(local, tip, base) {
+  const unreached = gitText(local, ['rev-list', '--no-merges', tip, '--not', ...base.refs, '--']).split('\n').filter(Boolean);
+  if (!unreached.length) return [];
+  const cherry = new Set(gitText(local, ['cherry', base.refs[0], tip]).split('\n')
+    .filter(line => line.startsWith('+ ')).map(line => line.slice(2).trim()));
+  return unreached.filter(commit => cherry.has(commit));
+}
+
+function parseWorktrees(text) {
+  return text.split('\0\0').filter(Boolean).map(record => Object.fromEntries(record.split('\0').filter(Boolean).map(row => {
+    const i = row.indexOf(' ');
+    return i < 0 ? [row, true] : [row.slice(0, i), row.slice(i + 1)];
+  })));
+}
+
+/** Inspect one repository. Never fetches: remote refs are as of the last fetch. */
+export function inspectUnmerged(directory, ctx) {
+  const local = localCtx(ctx, directory);
+  const report = { path: directory, defaultBranch: null, outstanding: 0, branches: [], kept: [], worktrees: [], prunable: [] };
+  const state = registeredPathState(directory, ctx);
+  if (state === 'missing') return { ...report, error: 'Registered path does not exist' };
+  if (state === 'not-a-repository') return { ...report, notRepository: true };
+  const root = gitText(local, ['rev-parse', '--path-format=absolute', '--show-toplevel']).trim();
+  report.path = root;
+  const base = defaultBranch(local);
+  if (!base) return { ...report, error: 'No default branch (no origin/HEAD, main, master or init.defaultBranch)' };
+  report.defaultBranch = base.name;
+  const keep = new Set(local.git(['config', '--get-all', 'totalrecall.keepBranch']).stdout?.split('\n').map(s => s.trim()).filter(Boolean) || []);
+
+  const trees = parseWorktrees(gitText(local, ['worktree', 'list', '--porcelain', '-z']));
+  const checkedOut = new Map(trees.filter(t => typeof t.branch === 'string').map(t => [t.branch.replace(/^refs\/heads\//, ''), t.worktree]));
+
+  const rows = gitText(local, ['for-each-ref', '--format=%(refname:short)%00%(objectname)%00%(committerdate:iso-strict)%00%(upstream:short)%00%(subject)', 'refs/heads']).split('\n').filter(Boolean);
+  for (const row of rows) {
+    const [branch, tip, lastCommitAt, upstream, subject] = row.split('\0');
+    if (branch === base.name) continue;
+    const unique = uniqueCommits(local, tip, base);
+    if (!unique.length) continue;
+    const onRemote = Number(gitText(local, ['rev-list', '--count', tip, '--not', '--remotes', '--']).trim()) === 0;
+    const entry = { branch, commits: unique.length, lastCommitAt, subject, upstream: upstream || null, pushed: onRemote, worktree: checkedOut.get(branch) || null };
+    if (keep.has(branch)) report.kept.push(entry); else report.branches.push(entry);
+  }
+
+  trees.forEach((tree, index) => {
+    const primary = index === 0;
+    const branch = typeof tree.branch === 'string' ? tree.branch.replace(/^refs\/heads\//, '') : null;
+    if (tree.prunable || !existsSync(tree.worktree)) {
+      if (!primary) report.prunable.push({ path: tree.worktree, branch, reason: 'directory is gone; git worktree prune removes the record' });
+      return;
+    }
+    // The primary checkout on the default branch is ongoing work on that branch, which audit and fleet report.
+    if (primary && branch === base.name) return;
+    const tctx = localCtx(ctx, tree.worktree);
+    const status = gitText(tctx, ['status', '--porcelain=v1', '-z']);
+    const uncommitted = status.split('\0').filter(entry => /^[ MADRCU?!]{2} /.test(entry)).length;
+    const orphanCommits = branch ? 0 : Number(gitText(tctx, ['rev-list', '--count', 'HEAD', '--not', '--branches', '--tags', '--remotes', '--']).trim());
+    if (!uncommitted && !orphanCommits) return;
+    report.worktrees.push({ path: tree.worktree, branch, detached: !branch, uncommitted, orphanCommits, locked: Boolean(tree.locked), primary });
+  });
+  report.outstanding = report.branches.length + report.worktrees.length;
+  return report;
+}
+
+function describeRepo(repo, home) {
+  const rel = p => (home && p.startsWith(`${home}${path.sep}`) ? `~${p.slice(home.length)}` : p);
+  const parts = [
+    ...repo.branches.map(b => `branch ${b.branch} (+${b.commits}${b.pushed ? '' : ', not pushed'})`),
+    ...repo.worktrees.map(w => `worktree ${rel(w.path)} (${[w.uncommitted ? `${w.uncommitted} uncommitted` : '', w.orphanCommits ? `${w.orphanCommits} commits on no branch` : ''].filter(Boolean).join(', ')})`),
+  ];
+  return `${rel(repo.path)}: ${parts.join('; ')}`;
+}
+
+export function summarize(repositories, home = process.env.HOME) {
+  const outstanding = repositories.reduce((n, repo) => n + repo.outstanding, 0);
+  const failed = repositories.filter(repo => repo.error);
+  if (!outstanding) {
+    const count = repositories.filter(repo => !repo.notRepository).length;
+    const scope = repositories.length === 1 ? 'in this repository' : `in ${count} repositories`;
+    return `No branch or worktree holds work outside the default branch ${scope}${failed.length ? `; ${failed.length} could not be read` : ''}.`;
+  }
+  const head = `${outstanding} branch${outstanding === 1 ? '' : 'es'} or worktree${outstanding === 1 ? '' : 's'} hold work not in the default branch: `;
+  let text = head;
+  const withWork = repositories.filter(repo => repo.outstanding);
+  for (let i = 0; i < withWork.length; i++) {
+    const next = `${i ? ' | ' : ''}${describeRepo(withWork[i], home)}`;
+    if (text.length + next.length > SUMMARY_LIMIT) { text += ` | and ${withWork.length - i} more repositor${withWork.length - i === 1 ? 'y' : 'ies'}`; break; }
+    text += next;
+  }
+  return `${text}${failed.length ? `. ${failed.length} repositor${failed.length === 1 ? 'y' : 'ies'} could not be read` : ''}. Details: total-recall git unmerged${repositories.length > 1 ? ' --registered' : ''}.`;
+}
+
+function textReport(repositories, summary) {
+  const lines = [];
+  for (const repo of repositories) {
+    if (repo.error) { lines.push(`${repo.path}: ${repo.error}`); continue; }
+    if (repo.notRepository) continue;
+    if (!repo.outstanding && !repo.kept.length && !repo.prunable.length) continue;
+    lines.push(`${repo.path} (default ${repo.defaultBranch})`);
+    for (const b of repo.branches) lines.push(`  branch ${b.branch}: ${b.commits} commit${b.commits === 1 ? '' : 's'} not in ${repo.defaultBranch}${b.pushed ? '' : ', not pushed'}; last ${b.lastCommitAt} "${b.subject}"${b.worktree ? `; checked out at ${b.worktree}` : ''}`);
+    for (const w of repo.worktrees) lines.push(`  worktree ${w.path} (${w.branch || 'detached HEAD'}${w.locked ? ', locked' : ''}): ${w.uncommitted} uncommitted file${w.uncommitted === 1 ? '' : 's'}${w.orphanCommits ? `, ${w.orphanCommits} commit${w.orphanCommits === 1 ? '' : 's'} on no branch` : ''}`);
+    for (const b of repo.kept) lines.push(`  kept ${b.branch}: ${b.commits} commit${b.commits === 1 ? '' : 's'} not in ${repo.defaultBranch} (totalrecall.keepBranch)`);
+    for (const p of repo.prunable) lines.push(`  stale worktree record ${p.path}${p.branch ? ` (${p.branch})` : ''}: ${p.reason}`);
+  }
+  return [...lines, summary].join('\n');
+}
+
+async function run(args, ctx) {
+  try {
+    const unknown = args.filter(a => a !== '--registered');
+    if (unknown.length) throw new Error('Use unmerged [--registered] [--json]');
+    let directories;
+    if (args.includes('--registered')) directories = registeredRepositories(ctx);
+    else {
+      const top = ctx.git(['rev-parse', '--path-format=absolute', '--show-toplevel']);
+      if (top.status !== 0) throw new Error('Not inside a git repository; use --registered for every registered repository');
+      directories = [top.stdout.trim()];
+    }
+    const repositories = directories.map(directory => {
+      try { return inspectUnmerged(directory, ctx); }
+      catch (error) { return { path: directory, error: error.message, outstanding: 0, branches: [], kept: [], worktrees: [], prunable: [] }; }
+    });
+    const ok = repositories.every(repo => !repo.error);
+    const outstanding = repositories.reduce((n, repo) => n + repo.outstanding, 0);
+    const summary = summarize(repositories);
+    output(ctx, { ok, outstanding, summary, repositories }, textReport(repositories, summary));
+    return ok ? 0 : 1;
+  } catch (error) { return failure(ctx, error); }
+}
+
+export const operations = {
+  unmerged: {
+    summary: 'Branches and worktrees whose commits or changes are not in the default branch',
+    usage: 'unmerged [--registered] [--json]   keep a branch on purpose: git config --add totalrecall.keepBranch <name>',
+    run,
+  },
+};

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/change-comparison.md

@@ -0,0 +1,27 @@
+---
+type: ui-chunk:chunk
+title: Git change comparison
+description: Compare unstaged, staged, or base-relative changes using the owner diff operation.
+timestamp: "2026-11-08T09:20:00Z"
+plugin: git
+id: change-comparison
+intents: [review git diff, check staged files, compare branch to base, read diff stats, show a patch]
+surfaces: [page, right]
+operations: [diff]
+data: ["diff:/ok", "diff:/cached", "diff:/diffStat", "diff:/timestamp"]
+---
+
+<style>
+  .sentinel-diff { padding:var(--spacing-md); border-block:1px solid var(--color-border); background:var(--color-surface); }
+  .sentinel-diff h2 { margin-top:0; }
+  .sentinel-diff dt { color:var(--color-accent); }
+  .sentinel-diff dd { margin:0 0 .45em; }
+</style>
+<section class="sentinel-diff">
+  <h2>Choose a comparison</h2>
+  <dl>
+    <dt>Working tree</dt><dd>Read the current changes against the index.</dd>
+    <dt>Staged</dt><dd>Review the index against the selected base.</dd>
+    <dt>Patch</dt><dd>Use <code>--patch</code> for line changes. The Home displays file statistics.</dd>
+  </dl>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/commit-identity.md

@@ -0,0 +1,22 @@
+---
+type: ui-chunk:chunk
+title: Commit identity audit
+description: Check whether a commit identity is configured and count machine addresses recorded in local history.
+timestamp: "2026-11-08T09:20:00Z"
+plugin: git
+id: commit-identity
+intents: [check git author identity, verify commit email, audit machine addresses, git author history]
+surfaces: [page]
+operations: [identity]
+data: ["identity:/ok", "identity:/machineCommits"]
+---
+
+<style>
+  .sentinel-identity { padding:var(--spacing-md); border-inline-start:3px solid var(--color-accent); background:var(--color-surface); }
+  .sentinel-identity h2 { margin-top:0; }
+  .sentinel-identity p { color:var(--color-muted); }
+</style>
+<section class="sentinel-identity">
+  <h2>Check the configured author</h2>
+  <p>The identity audit checks Git’s current author configuration and counts commits with a machine-derived address. Review the count separately from the current configuration.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/create-worktree.md

@@ -0,0 +1,25 @@
+---
+type: ui-chunk:chunk
+title: Create a detached worktree
+description: Create a linked Git worktree from an explicit base ref and verify its resulting revision.
+timestamp: "2026-11-08T09:20:00Z"
+plugin: git
+id: create-worktree
+intents: [create git worktree, isolate git checkout, add detached worktree, choose worktree base]
+surfaces: [page]
+operations: [worktree-create]
+data: ["worktree-create:/ok", "worktree-create:/head", "worktree-create:/detached"]
+---
+
+<style>
+  .sentinel-create { padding:var(--spacing-md); background:var(--color-surface); border-radius:var(--radius-md); }
+  .sentinel-create h2 { margin-top:0; }
+  .sentinel-create li::marker { color:var(--color-accent); }
+</style>
+<section class="sentinel-create">
+  <h2>Prepare an isolated checkout</h2>
+  <ol>
+    <li>Choose a destination and a base ref.</li>
+    <li>Confirm the destination before creation, then verify the detached revision.</li>
+  </ol>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/registered-worktrees.md

@@ -0,0 +1,22 @@
+---
+type: ui-chunk:chunk
+title: Registered Git worktrees
+description: List the repository's main and linked worktrees and inspect their checked-out revisions.
+timestamp: "2026-11-08T09:20:00Z"
+plugin: git
+id: registered-worktrees
+intents: [list git worktrees, inspect linked worktrees, find detached worktree, show active checkouts]
+surfaces: [page, right]
+operations: [worktree-list]
+data: ["worktree-list:/ok", "worktree-list:/worktrees/0/head"]
+---
+
+<style>
+  .sentinel-index { padding:var(--spacing-md); border:1px solid var(--color-border); background:var(--color-surface); }
+  .sentinel-index h2 { margin-top:0; }
+  .sentinel-index b { color:var(--color-accent); }
+</style>
+<section class="sentinel-index">
+  <h2>Read the worktree register</h2>
+  <p>Compare the revision and branch of each registered checkout. The Home labels <b>Main</b> and <b>Current</b> separately.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/remove-worktree.md

@@ -0,0 +1,23 @@
+---
+type: ui-chunk:chunk
+title: Remove a linked worktree
+description: Review a registered linked worktree, confirm its target, and read the removal result.
+timestamp: "2026-11-08T09:20:00Z"
+plugin: git
+id: remove-worktree
+intents: [remove linked git worktree, clean up isolated checkout, review worktree removal, dirty worktree refused]
+surfaces: [page]
+operations: [worktree-remove]
+data: ["worktree-remove:/ok", "worktree-remove:/removed"]
+---
+
+<style>
+  .sentinel-remove { padding:var(--spacing-md); border-inline-start:3px solid var(--color-danger); background:var(--color-surface); }
+  .sentinel-remove h2 { margin-top:0; }
+  .sentinel-remove small { color:var(--color-muted); }
+</style>
+<section class="sentinel-remove">
+  <h2>Confirm the linked checkout</h2>
+  <p>Select the worktree by path. The Home checks Git’s removal receipt before refreshing the register.</p>
+  <small>Git refuses ordinary removal when the worktree contains local changes.</small>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/repository-ledger.md

@@ -0,0 +1,25 @@
+---
+type: ui-chunk:chunk
+title: Git repository ledger
+description: Read the active checkout, local upstream comparison, dirty files, conflicts, and stashes.
+timestamp: "2026-11-08T09:20:00Z"
+plugin: git
+id: repository-ledger
+intents: [audit git repository, check working tree, git branch and upstream, count unpushed commits, show conflicts and stashes]
+surfaces: [page, right]
+panel: repository
+operations: [audit]
+data: ["audit:/headState", "audit:/upstreamStatus", "audit:/isClean", "audit:/unpushedCommits", "audit:/conflictedFiles", "audit:/totalDirty", "audit:/stashCount", "audit:/timestamp"]
+---
+
+<style>
+  .sentinel-ledger { padding:var(--spacing-md); border-inline-start:3px solid var(--color-accent); color:var(--color-text); background:var(--color-surface); }
+  .sentinel-ledger h2 { margin:.3rem 0; font:600 clamp(1.55rem,5vw,2.2rem) var(--typography-heading-font-family,Georgia,serif); }
+  .sentinel-ledger p { margin:0; }
+  .sentinel-ledger small { text-transform:uppercase; letter-spacing:.11em; color:var(--color-accent); }
+</style>
+<header class="sentinel-ledger">
+  <small>Git</small>
+  <h2>Read the current checkout</h2>
+  <p>Review repository state and its registered worktrees. Ahead and behind come from the local tracking ref.</p>
+</header>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/unmerged-work.md

@@ -0,0 +1,22 @@
+---
+type: ui-chunk:chunk
+title: Work not in the default branch
+description: Find branches with commits the default branch lacks, worktrees with uncommitted changes and detached worktrees holding commits on no branch.
+timestamp: "2026-11-12T21:30:00Z"
+plugin: git
+id: unmerged-work
+intents: [find unmerged branches, find unfinished worktrees, check for work that never landed, see what is not merged into main]
+surfaces: [page, right]
+operations: [unmerged]
+data: ["unmerged:/outstanding", "unmerged:/summary", "unmerged:/repositories/0/branches", "unmerged:/repositories/0/worktrees", "unmerged:/repositories/0/kept"]
+---
+
+<style>
+  .sentinel-unmerged { padding:var(--spacing-md); border:1px solid var(--color-border); background:var(--color-surface); }
+  .sentinel-unmerged h2 { margin-top:0; }
+  .sentinel-unmerged b { color:var(--color-accent); }
+</style>
+<section class="sentinel-unmerged">
+  <h2>Land what is still outside the default branch</h2>
+  <p>Each branch shows its commits the default branch lacks and whether they are pushed. Each worktree shows its <b>uncommitted</b> files and any commits on no branch, which removing the worktree would lose. Merge or report every item before ending the work.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/upstream-divergence.md

@@ -0,0 +1,17 @@
+---
+type: ui-chunk:chunk
+plugin: git
+id: upstream-divergence
+title: Check branch divergence before integration
+description: Review upstream state and local ahead or behind counts before choosing a branch integration action.
+timestamp: "2026-11-08T23:12:00Z"
+intents: [check commits ahead and behind, inspect missing upstream, prepare branch integration]
+surfaces: [page]
+panel: repository
+operations: [audit]
+data: ["audit:/headState", "audit:/upstreamStatus", "audit:/unpushedCommits", "audit:/behindCommits"]
+---
+<section>
+  <h2>Read branch divergence</h2>
+  <p>Check whether this checkout has an upstream. On a tracked branch, compare commits ahead and behind, then check the working tree before selecting an integration action.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/worktree-conflict-triage.md

@@ -0,0 +1,17 @@
+---
+type: ui-chunk:chunk
+plugin: git
+id: worktree-conflict-triage
+title: Triage conflicts in a linked checkout
+description: Find unresolved conflicts and distinguish them from staged, unstaged and untracked work before opening a diff.
+timestamp: "2026-11-08T23:12:00Z"
+intents: [triage merge conflicts, compare staged and unstaged work during a conflict, inspect dirty worktree before cleanup]
+surfaces: [page]
+panel: repository
+operations: [audit, diff]
+data: ["audit:/conflictedFiles", "audit:/stagedFiles", "audit:/unstagedFiles", "audit:/untrackedFiles", "diff:/diffStat"]
+---
+<section>
+  <h2>Separate conflicts from other local changes</h2>
+  <p>Read the conflict count first. Then open diff statistics for the relevant working or staged changes. Preserve the linked checkout until its local work is resolved.</p>
+</section>

package/scaffold/.agent/skills/total-recall/plugins/git/ui/chunks/worktree-terminal.md

@@ -0,0 +1,22 @@
+---
+type: ui-chunk:chunk
+title: Worktree compatibility commands
+description: Use the owner compatibility command in the terminal to list, create, or remove linked worktrees.
+timestamp: "2026-11-08T09:20:00Z"
+plugin: git
+id: worktree-terminal
+intents: [git sentinel worktree command, worktree compatibility syntax, terminal git worktree list, worktree create remove alias]
+surfaces: [page]
+operations: [worktree]
+data: ["worktree:/ok", "worktree:/worktrees/0/head", "worktree:/removed"]
+---
+
+<style>
+  .sentinel-terminal { padding:var(--spacing-md); border:1px dashed var(--color-border); background:var(--color-surface); }
+  .sentinel-terminal h2 { margin-top:0; }
+  .sentinel-terminal code { color:var(--color-accent); overflow-wrap:anywhere; }
+</style>
+<section class="sentinel-terminal">
+  <h2>Use the compatibility command</h2>
+  <p><code>total-recall git worktree-list</code> reads the register. Select <code>create</code> or <code>remove</code> with the required path for an explicit change.</p>
+</section>