kenaz 0.3.6 → 0.3.7

package/core/.collaboration/core/reconcile.js

@@ -0,0 +1,193 @@
+'use strict';
+/**
+ * TASK_2404: close cards whose task branches already landed on <remote>/<base>
+ * (cross-node pool merge, external rebase+merge) without running post-complete.
+ *
+ * landed(card) = the card has >=1 task branch (local or remote task/<id>*, or card.branch)
+ * AND every one of them is an ancestor of <remote>/<base> AND each carries >=1 commit of its own
+ * (a freshly forked, still-empty branch is trivially an ancestor of base; it has landed nothing).
+ *
+ * Only local refs are read (the <remote>/<base> remote-tracking ref); nothing here fetches.
+ */
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const TELEMETRY = ['.kenaz/sessions', '.kenaz/specialist', '.formation/.dispatch-branch', '.formation/analytics', '.kenaz/channel_heartbeats.jsonl'];
+const LIVE_PIDLESS_MS = 3600000; // pid-less dispatch entries count as live for 60 min (DISPATCH_LOCK_STALE_MS)
+
+function git(cwd, args) {
+  return execFileSync('git', args, { cwd, encoding: 'utf8', windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 64 * 1024 * 1024 }).trim();
+}
+function gitOk(cwd, args) { try { git(cwd, args); return true; } catch { return false; } }
+const norm = (p) => path.resolve(p).replace(/\\/g, '/').toLowerCase();
+const isTelemetry = (rel) => TELEMETRY.some((t) => rel === t || rel.startsWith(t + '/'));
+
+/** Remote-tracking base ref when present, else the local base branch (null when neither exists). */
+function resolveBaseRef(repo, remote, base) {
+  for (const ref of [`refs/remotes/${remote}/${base}`, `refs/heads/${base}`]) {
+    if (gitOk(repo, ['rev-parse', '--verify', '--quiet', ref])) return ref;
+  }
+  return null;
+}
+
+/** Branch refs of a card: local + remote task/<id>* plus card.branch. [{ref, name, sha}] */
+function findCardBranches(repo, card, remote) {
+  const idLower = String(card.id).toLowerCase();
+  const out = git(repo, ['for-each-ref', '--format=%(refname) %(objectname)', 'refs/heads/task', `refs/remotes/${remote}/task`]);
+  const prefixes = [`refs/heads/task/${idLower}`, `refs/remotes/${remote}/task/${idLower}`];
+  const found = [];
+  for (const line of out.split(/\r?\n/).filter(Boolean)) {
+    const [ref, sha] = line.split(' ');
+    // `task/task_12` must not match `task/task_123`: allow only a non-digit after the id.
+    if (prefixes.some((p) => ref === p || (ref.startsWith(p) && !/^\d/.test(ref.slice(p.length))))) found.push({ ref, sha });
+  }
+  if (card.branch) {
+    for (const ref of [`refs/heads/${card.branch}`, `refs/remotes/${remote}/${card.branch}`]) {
+      if (found.some((f) => f.ref === ref)) continue;
+      try { found.push({ ref, sha: git(repo, ['rev-parse', '--verify', '--quiet', ref]) }); } catch { /* absent */ }
+    }
+  }
+  return found.map((f) => ({ ...f, name: f.ref.replace(/^refs\/(heads|remotes\/[^/]+)\//, '') }));
+}
+
+/** True unless the LOCAL branch's reflog proves its tip is still its creation commit (no commits of its own). */
+function hasOwnCommits(repo, b) {
+  if (!b.ref.startsWith('refs/heads/')) return true; // remote-tracking refs carry no reflog
+  try {
+    const lines = git(repo, ['reflog', 'show', '--format=%H', b.ref]).split(/\r?\n/).filter(Boolean);
+    return !(lines.length > 0 && lines[lines.length - 1] === b.sha);
+  } catch { return true; }
+}
+
+/** First commit on base that contains `sha` (one ancestry-path walk); `sha` itself when nothing lies between. */
+function landingCommit(repo, baseRef, sha) {
+  try {
+    const first = git(repo, ['rev-list', '--reverse', '--ancestry-path', `${sha}..${baseRef}`]).split(/\r?\n/)[0];
+    return first || sha;
+  } catch { return null; }
+}
+
+/** @returns {{landed:boolean, branches:object[], landing:string|null, baseRef:string|null, reason?:string}} */
+function assessCard(repo, card, { remote = 'origin', base = 'main' } = {}) {
+  const baseRef = resolveBaseRef(repo, remote, base);
+  if (!baseRef) return { landed: false, branches: [], landing: null, baseRef, reason: `no ${remote}/${base} or ${base} ref` };
+  const branches = findCardBranches(repo, card, remote);
+  if (!branches.length) return { landed: false, branches, landing: null, baseRef, reason: 'no branch' };
+  let reason = null;
+  for (const br of branches) {
+    if (!gitOk(repo, ['merge-base', '--is-ancestor', br.sha, baseRef])) reason = `${br.name} is not an ancestor of base`;
+    else if (!hasOwnCommits(repo, br)) reason = `${br.name} has no commits beyond its fork point (fresh branch, nothing landed)`;
+    if (reason) break;
+  }
+  const landed = !reason;
+  return { landed, branches, landing: landed ? landingCommit(repo, baseRef, branches[0].sha) : null, baseRef, reason };
+}
+
+/** Why a landed card's worktree must be kept; null = safe to remove. */
+function worktreeKeepReason(repo, wt, card, baseRef, activeDispatches, now) {
+  if (!fs.existsSync(wt.path)) return 'path missing';
+  const p = norm(wt.path);
+  const cwd = norm(process.cwd());
+  if (cwd === p || cwd.startsWith(p + '/')) return 'current working directory is inside it';
+  if (wt.locked) return 'locked';
+  if (!wt.branch) return 'detached HEAD';
+  const live = (activeDispatches || []).some((d) => {
+    if (!((d.worktree_path && norm(d.worktree_path) === p) || d.taskId === card.id)) return false;
+    if (d.pid) { try { process.kill(d.pid, 0); return true; } catch (e) { return e.code === 'EPERM'; } }
+    return now - Date.parse(d.startedAt || 0) < LIVE_PIDLESS_MS;
+  });
+  if (live) return 'live dispatch/agent registered for it';
+  if (!gitOk(wt.path, ['merge-base', '--is-ancestor', 'HEAD', baseRef])) return 'HEAD is not an ancestor of base';
+  if (!hasOwnCommits(repo, { ref: `refs/heads/${wt.branch}`, sha: git(wt.path, ['rev-parse', 'HEAD']) })) return 'no commits beyond its fork point (fresh worktree)';
+  const dirty = git(wt.path, ['status', '--porcelain', '--untracked-files=no']).split(/\r?\n/).filter(Boolean)
+    .map((l) => l.slice(3).replace(/^"|"$/g, '')).filter((f) => !isTelemetry(f));
+  if (dirty.length) return `tracked tree dirty: ${dirty.slice(0, 3).join(', ')}`;
+  const stack = [wt.path];
+  while (stack.length) {
+    const dir = stack.pop();
+    let names; try { names = fs.readdirSync(dir); } catch { continue; }
+    for (const n of names) {
+      if (n === '.git') continue;
+      const f = path.join(dir, n);
+      let st; try { st = fs.lstatSync(f); } catch { continue; }
+      // a node_modules link is dispatch-managed and unlinked before removal; any other link blocks
+      if (st.isSymbolicLink()) { if (n !== 'node_modules') return `contains symlink/junction: ${path.relative(wt.path, f)}`; }
+      else if (st.isDirectory()) stack.push(f);
+    }
+  }
+  return null;
+}
+
+function removeWorktree(repo, wt) {
+  require('../../.formation/tools/utils').unlinkNodeModulesBestEffort(wt.path); // `worktree remove` must not traverse the junction
+  git(repo, ['worktree', 'remove', '--force', wt.path]);
+  try { git(repo, ['worktree', 'prune']); } catch { /* non-fatal */ }
+}
+
+const isKeepOpen = (c) => c.keep_open === true || c.keep_open === 'true';
+
+/**
+ * @param {TaskAPI} api
+ * @param {{remote?:string, base?:string, apply?:boolean, worktrees?:boolean, activeDispatches?:object[], now?:number, log?:Function}} opts
+ */
+async function reconcile(api, opts = {}) {
+  const { remote = 'origin', base = 'main', apply = false, worktrees = false } = opts;
+  const log = opts.log || console.log;
+  const repo = api._resolveProjectRoot();
+  const now = opts.now || Date.now();
+  const active = opts.activeDispatches || (() => { try { return require('../../.formation/tools/dispatch-registry').readActiveDispatches(); } catch { return []; } })();
+  const wtList = worktrees ? require('../../.formation/tools/worktree-reclaim').listRegisteredWorktrees(repo).worktrees : [];
+  const rows = [];
+  for (const card of await api.queryTasks({ status: 'active' })) {
+    const a = assessCard(repo, card, { remote, base });
+    const keepOpen = isKeepOpen(card);
+    const mine = wtList.filter((w) => w.branch && a.branches.some((b) => b.name === w.branch));
+    const row = { card: card.id, branches: a.branches.map((b) => b.name), landed: a.landed, landing: a.landing, keepOpen, worktrees: mine.map((w) => w.path), closed: false, notes: [] };
+    if (a.landed && !keepOpen && apply) {
+      await api.completeTask(card.id, { skipPostComplete: true, external: { landing_sha: a.landing, landed_into: a.baseRef.replace(/^refs\/(heads|remotes)\//, '') } });
+      row.closed = true;
+    }
+    if (worktrees) {
+      for (const w of mine) {
+        const why = !a.landed ? `card not landed: ${a.reason}` : keepOpen ? 'card is keep_open' : worktreeKeepReason(repo, w, card, a.baseRef, active, now);
+        if (why) row.notes.push(`KEEP ${w.path}: ${why}`);
+        else if (!apply) row.notes.push(`would remove ${w.path}`);
+        else { try { removeWorktree(repo, w); row.notes.push(`removed ${w.path}`); } catch (e) { row.notes.push(`KEEP ${w.path}: remove failed: ${String(e.message).split('\n')[0]}`); } }
+      }
+    }
+    rows.push(row);
+  }
+  log(`reconcile ${apply ? '(APPLY)' : '(dry-run)'} against ${remote}/${base}: ${rows.length} active card(s)`);
+  for (const r of rows) {
+    const state = r.landed ? (r.keepOpen ? 'landed (keep_open: kept open)' : (r.closed ? 'landed -> closed' : 'landed')) : 'not landed';
+    log(`${r.card}\t${state}\tbranches=${r.branches.join(',') || '-'}\tlanding=${r.landing ? r.landing.slice(0, 10) : '-'}\tworktree=${r.worktrees.join(',') || '-'}`);
+    for (const n of r.notes) log(`    ${n}`);
+  }
+  return rows;
+}
+
+/** The landed assessment, or null when not landed / not decidable (non-git dir, no base ref). */
+function landedAssessment(repo, card, opts) {
+  try { const a = assessCard(repo, card, opts); return a.landed ? a : null; } catch { return null; }
+}
+
+/** Local-only count (no fetch; remote-tracking refs) of active cards already landed and not keep_open. */
+function countLanded(repo, cards, opts) {
+  return cards.filter((c) => !isKeepOpen(c) && landedAssessment(repo, c, opts)).length;
+}
+
+/**
+ * Landed elsewhere = landed AND no registered worktree still has one of its branches checked out.
+ * A worktree on the branch means a local land just merged it (verify-and-land merges, then runs
+ * complete), so post-complete still has a delivery to read and complete must proceed.
+ */
+function externalLanding(repo, card, opts) {
+  const a = landedAssessment(repo, card, opts);
+  if (!a) return null;
+  const names = new Set(a.branches.map((b) => b.name));
+  const wts = require('../../.formation/tools/worktree-reclaim').listRegisteredWorktrees(repo).worktrees;
+  return wts.some((w) => w.branch && names.has(String(w.branch).replace(/^refs\/heads\//, ''))) ? null : a;
+}
+
+module.exports = { reconcile, assessCard, landedAssessment, externalLanding, countLanded };

package/core/.collaboration/core/task-2404-reconcile.test.js

@@ -0,0 +1,135 @@
+// TASK_2404 -- `task-api reconcile` + the plain-complete guard for externally landed cards.
+// Temp git repos under os.tmpdir() only (origin is a local bare repo; nothing fetches, no network).
+// Usage: node .collaboration/core/task-2404-reconcile.test.js
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const cp = require('child_process');
+
+// No network / no side processes: stub task-sync, the pool push (recorded) and the detached health capture.
+const syncPath = require.resolve('../../.formation/tools/task-sync');
+require.cache[syncPath] = { id: syncPath, filename: syncPath, loaded: true, exports: { syncTaskStatus: async () => ({}) } };
+const realSpawn = cp.spawn;
+cp.spawn = function (cmd, argv, opts) {
+  if (Array.isArray(argv) && argv.some(a => typeof a === 'string' && a.includes('const CFG'))) return { unref() {}, on() {} };
+  return realSpawn.apply(this, arguments);
+};
+const { TaskAPI, toYAML, setPoolStatusPush } = require('./task-api.js');
+const pushes = [];
+setPoolStatusPush({ pushPoolStatus: async (a) => { pushes.push(a.task && a.task.id); return { pushed: true }; } });
+
+const SB = fs.mkdtempSync(path.join(os.tmpdir(), 't2404_'));
+const ORIGIN = path.join(SB, 'origin.git');
+const REPO = path.join(SB, 'repo');
+const WT = path.join(SB, 'wts');
+const git = (cwd, ...a) => cp.execFileSync('git', a, { cwd, encoding: 'utf8', windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+let pass = 0, fail = 0;
+const check = (n, c, d) => { console.log((c ? 'PASS' : 'FAIL') + ' | ' + n + (c ? '' : ' | ' + d)); c ? pass++ : fail++; };
+const capture = async (fn) => { const lines = []; const rows = await fn((l) => lines.push(l)); return { rows, out: lines.join('\n') }; };
+
+function setup() {
+  fs.mkdirSync(ORIGIN, { recursive: true });
+  git(ORIGIN, 'init', '-q', '--bare', '-b', 'main');
+  fs.mkdirSync(REPO, { recursive: true });
+  git(REPO, 'init', '-q', '-b', 'main');
+  git(REPO, 'config', 'user.email', 't@example.com'); git(REPO, 'config', 'user.name', 't');
+  git(REPO, 'remote', 'add', 'origin', ORIGIN);
+  fs.writeFileSync(path.join(REPO, 'README.md'), 'base\n');
+  git(REPO, 'add', '-A'); git(REPO, 'commit', '-q', '-m', 'base');
+  git(REPO, 'push', '-q', 'origin', 'main');
+  for (const d of ['backlog', 'active', 'done', 'blocked', 'cancel', 'archived']) fs.mkdirSync(path.join(REPO, '.kenaz', 'tasks', d), { recursive: true });
+}
+// branch task/task_<n> with one commit, optionally in a worktree
+function mkBranch(n, { worktree = false } = {}) {
+  const b = `task/task_${n}`;
+  if (worktree) { fs.mkdirSync(WT, { recursive: true }); git(REPO, 'worktree', 'add', '-q', '-b', b, path.join(WT, `task_${n}`), 'main'); }
+  else git(REPO, 'branch', b, 'main');
+  const dir = worktree ? path.join(WT, `task_${n}`) : null;
+  const work = dir || REPO;
+  if (!dir) git(REPO, 'checkout', '-q', b);
+  fs.writeFileSync(path.join(work, `f${n}.txt`), `work ${n}\n`);
+  git(work, 'add', '-A'); git(work, 'commit', '-q', '-m', `[TASK_${n}] work`);
+  if (!dir) git(REPO, 'checkout', '-q', 'main');
+  return { branch: b, dir };
+}
+const mergeToOriginMain = (b) => { git(REPO, 'merge', '-q', '--no-ff', '-m', `merge ${b}`, b); git(REPO, 'push', '-q', 'origin', 'main'); };
+const card = (n, extra = {}) => fs.writeFileSync(path.join(REPO, '.kenaz', 'tasks', 'active', `TASK_${n}_t.yaml`),
+  toYAML({ id: `TASK_${n}`, title: `t${n}`, priority: 'P2', status: 'in_progress', ...extra }));
+const inDir = (n, d) => fs.readdirSync(path.join(REPO, '.kenaz', 'tasks', d)).some(f => f.startsWith(`TASK_${n}_`));
+
+(async () => {
+  try {
+    setup();
+    // A merged, B unmerged, C merged + keep_open; D clean landed worktree; E dirty landed worktree;
+    // F landed but a dispatch is live; G fresh worktree (no commits); H unmerged worktree
+    mkBranch(9001); mkBranch(9002); mkBranch(9003);
+    const D = mkBranch(9004, { worktree: true }), E = mkBranch(9005, { worktree: true }), F = mkBranch(9006, { worktree: true });
+    mkBranch(9008, { worktree: true });
+    fs.mkdirSync(WT, { recursive: true });
+    git(REPO, 'worktree', 'add', '-q', '-b', 'task/task_9007', path.join(WT, 'task_9007'), 'main'); // G: no commits
+    for (const n of [9001, 9003, 9004, 9005, 9006]) mergeToOriginMain(`task/task_${n}`);
+    fs.writeFileSync(path.join(E.dir, 'f9005.txt'), 'dirty edit\n'); // tracked + modified
+    for (const n of [9001, 9002]) card(n);
+    card(9003, { keep_open: true });
+
+    const api = new TaskAPI({ tasksDir: path.join(REPO, '.kenaz', 'tasks'), projectPath: REPO });
+
+    // dry-run
+    let r = await capture((log) => api.constructor && require('./reconcile').reconcile(api, { log }));
+    const row = (id) => r.rows.find(x => x.card === `TASK_${id}`);
+    check('dry-run: A landed', row(9001).landed === true && !!row(9001).landing, JSON.stringify(row(9001)));
+    check('dry-run: B not landed', row(9002).landed === false);
+    check('dry-run: C landed but kept open', row(9003).landed === true && row(9003).keepOpen === true && /keep_open/.test(r.out));
+    check('dry-run closes nothing', inDir(9001, 'active') && inDir(9003, 'active'));
+
+    // complete guard (new behavior): A refused, nothing written
+    let msg = null;
+    try { await api.completeTask('TASK_9001', {}); } catch (e) { msg = e.message; }
+    check('complete on landed card A is refused and points at reconcile', !!msg && /reconcile/.test(msg), msg);
+    check('refused complete left A active, wrote no outcome', inDir(9001, 'active') && !inDir(9001, 'done'));
+    // verify-and-land merges first, then runs complete while the task worktree still exists: not external
+    const { externalLanding, landedAssessment } = require('./reconcile');
+    const D4 = { id: 'TASK_9004' };
+    check('landed card with its worktree still present is not external (local land proceeds)',
+      !!landedAssessment(REPO, D4, {}) && externalLanding(REPO, D4, {}) === null);
+    check('landed card with no worktree is external', !!externalLanding(REPO, { id: 'TASK_9001' }, {}));
+
+    // --apply
+    pushes.length = 0;
+    r = await capture((log) => require('./reconcile').reconcile(api, { apply: true, log }));
+    check('apply closed A', inDir(9001, 'done') && !inDir(9001, 'active'));
+    check('apply left B active', inDir(9002, 'active'));
+    check('apply left keep_open C active', inDir(9003, 'active') && !inDir(9003, 'done'));
+    const doneFile = fs.readdirSync(path.join(REPO, '.kenaz', 'tasks', 'done')).find(f => f.startsWith('TASK_9001_'));
+    const doneTxt = fs.readFileSync(path.join(REPO, '.kenaz', 'tasks', 'done', doneFile), 'utf8');
+    const mainSha = git(REPO, 'rev-parse', 'origin/main');
+    const sha = (/^landing_sha:\s*(\w+)/m.exec(doneTxt) || [])[1];
+    check('A has integration: external', /^integration:\s*external\s*$/m.test(doneTxt), doneTxt);
+    check('A records the landing SHA (a commit on origin/main containing the branch)', !!sha && git(REPO, 'merge-base', '--is-ancestor', git(REPO, 'rev-parse', 'task/task_9001'), sha) === '' && git(REPO, 'merge-base', '--is-ancestor', sha, mainSha) === '', sha);
+    check('pool status pushed for the closed card', pushes.includes('TASK_9001'), JSON.stringify(pushes));
+
+    // worktree guards (dry-run first: nothing removed); these cards join after the first apply
+    for (const n of [9004, 9005, 9006, 9007, 9008]) card(n);
+    const live = [{ sessionId: 's', taskId: 'TASK_9006', worktree_path: F.dir, pid: process.pid, startedAt: new Date().toISOString() }];
+    r = await capture((log) => require('./reconcile').reconcile(api, { worktrees: true, activeDispatches: live, log }));
+    check('worktrees dry-run removes nothing', fs.existsSync(D.dir) && /would remove/.test(r.out));
+    r = await capture((log) => require('./reconcile').reconcile(api, { apply: true, worktrees: true, activeDispatches: live, log }));
+    check('landed clean worktree removed', !fs.existsSync(D.dir) && /removed .*task_9004/.test(r.out), r.out);
+    check('branch of removed worktree kept', git(REPO, 'branch', '--list', 'task/task_9004') !== '');
+    check('dirty worktree kept with reason', fs.existsSync(E.dir) && /KEEP .*task_9005: tracked tree dirty/.test(r.out), r.out);
+    check('live-dispatch worktree kept with reason', fs.existsSync(F.dir) && /KEEP .*task_9006: live dispatch/.test(r.out), r.out);
+    check('fresh worktree (no commits) kept with reason', fs.existsSync(path.join(WT, 'task_9007')) && /KEEP .*task_9007: .*no commits beyond its fork point/.test(r.out), r.out);
+    check('unlanded worktree kept with reason', fs.existsSync(path.join(WT, 'task_9008')) && /KEEP .*task_9008: card not landed/.test(r.out), r.out);
+
+    // boot-banner count is local-only and counts landed non-keep_open active cards
+    const n = require('./reconcile').countLanded(REPO, [{ id: 'TASK_9005' }, { id: 'TASK_9002' }, { id: 'TASK_9003', keep_open: true }], {});
+    check('countLanded: 1 (9005 landed; 9002 not; 9003 keep_open)', n === 1, String(n));
+  } catch (e) {
+    check('no exception', false, e && e.stack);
+  } finally {
+    cp.spawn = realSpawn;
+    try { fs.rmSync(SB, { recursive: true, force: true }); } catch { /* best effort */ }
+  }
+  console.log(`\n${pass} passed, ${fail} failed`);
+  process.exit(fail ? 1 : 0);
+})();

package/core/.collaboration/core/task-api.js

@@ -2094,6 +2094,17 @@ class TaskAPI {
       throw new Error(`無法從 backlog 直接完成 ${taskId}: move it to active first (node task-api.js move ${taskId} active), then complete.`);
     }
 
+    // TASK_2404: a card whose task branch is already an ancestor of <remote>/<base> landed elsewhere
+    // (cross-node pool, external rebase+merge). Full complete would run post-complete on a tree with
+    // nothing to deliver and write an empty-delivery outcome, so refuse and point at `reconcile`.
+    // Paths that never run post-complete (--skip-post-complete, reconcile --apply) are unaffected.
+    if (!options.skipPostComplete && !options.external) {
+      const landed = require('./reconcile').externalLanding(this._resolveProjectRoot(), task, {});
+      if (landed) {
+        throw new Error(`${taskId}: branch ${landed.branches.map(b => b.name).join(', ')} already landed on ${landed.baseRef.replace(/^refs\/(heads|remotes)\//, '')} (${String(landed.landing).slice(0, 10)}); a full complete would record an empty delivery. Run: node .collaboration/core/task-api.js reconcile --apply (or complete ${taskId} --skip-post-complete).`);
+      }
+    }
+
     const updatedTask = {
       ...task,
       executed_by: {
@@ -2103,6 +2114,13 @@ class TaskAPI {
       }
     };
 
+    // TASK_2404: externally landed card (reconcile): record how and where it landed
+    if (options.external) {
+      updatedTask.integration = 'external';
+      updatedTask.landing_sha = options.external.landing_sha || null;
+      updatedTask.landed_into = options.external.landed_into || null;
+    }
+
     // 設置實際工時（如果提供）
     if (options.actual_hours !== undefined) {
       updatedTask.actual_hours = options.actual_hours;
@@ -2682,6 +2700,7 @@ Commands:
     預設為整組取代（會回顯被移除的既有項目）；加 --append 改為追加到既有項目之後（與既有重複的項目會略過並回顯）
   node task-api.js claim TASK_ID
   node task-api.js complete TASK_ID [--actual-hours HOURS]
+  node task-api.js reconcile [--remote origin] [--base main] [--apply] [--worktrees]   關閉分支已併入 base 的 active 任務（預設 dry-run）
   node task-api.js move TASK_ID STATUS [--force]
   node task-api.js delete TASK_ID              (僅限 backlog 狀態)
   node task-api.js search KEYWORD
@@ -2768,7 +2787,14 @@ Create 選項:
 
       const command = args[0];
 
-      if (command === 'worktrees') {
+      if (command === 'reconcile') {
+        // TASK_2404: close active cards whose branches already landed on <remote>/<base>
+        const argOf = (n, d) => { const i = args.indexOf(n); return i >= 0 && args[i + 1] && !args[i + 1].startsWith('--') ? args[i + 1] : d; };
+        await require('./reconcile').reconcile(api, {
+          remote: argOf('--remote', 'origin'), base: argOf('--base', 'main'),
+          apply: args.includes('--apply'), worktrees: args.includes('--worktrees'),
+        });
+      } else if (command === 'worktrees') {
         // TASK_2297: list worktrees with reclaim eligibility; --reclaim removes eligible ones (manual path).
         const wr = require(path.join(__dirname, '..', '..', '.formation', 'tools', 'worktree-reclaim.js'));
         const wtRepo = path.resolve(cliProjectPath || process.cwd());

package/core/.specialist/tools/ansuz-boot-fast.js

@@ -1022,6 +1022,8 @@ async function main() {
   const wishesLine = formatWishesLine(await fetchOpenWishes(mcpBase, WISH_TIMEOUT_MS, IS_PINNED ? BASE : null));
   if (wishesLine) lines.push(wishesLine);
   for (const l of openCardLines()) lines.push(l);
+  const landedLine = landedActiveCardsLine();
+  if (landedLine) lines.push(landedLine);
   const peerLines = await fetchPendingPeerLines(mcpBase, WISH_TIMEOUT_MS, IS_PINNED ? BASE : process.env.CLAUDE_PROJECT_DIR || process.cwd());
   for (const l of peerLines) lines.push(l);
   lines.push('（boot 完成：依 Open cards 提議程；小修正直接做，中型工作開卡派工）');
@@ -1039,6 +1041,24 @@ if (require.main === module) {
   });
 }
 
+// TASK_2404: active cards whose task branch is already an ancestor of origin/main (local remote-tracking
+// refs only -- no fetch at boot). Silent when none or when anything fails.
+function landedActiveCardsLine() {
+  try {
+    const dir = path.join(resolveTasksDir(), 'active');
+    const pick = (txt, key) => {
+      const m = txt.match(new RegExp('^' + key + ':[ \\t]*(.*)$', 'm'));
+      return m ? m[1].trim().replace(/^['"]|['"]$/g, '') : '';
+    };
+    const cards = fs.readdirSync(dir).filter((f) => /\.ya?ml$/.test(f)).map((f) => {
+      const txt = fs.readFileSync(path.join(dir, f), 'utf8');
+      return { id: pick(txt, 'id'), branch: pick(txt, 'branch') || null, keep_open: pick(txt, 'keep_open') === 'true' };
+    }).filter((c) => c.id);
+    const n = require(path.join(__dirname, '..', '..', '.collaboration', 'core', 'reconcile.js')).countLanded(BASE, cards, {});
+    return n > 0 ? '[reconcile] ' + n + ' active cards already landed (task-api reconcile)' : null;
+  } catch { return null; }
+}
+
 module.exports = {
   isOutsideAnyProject,
   harnessSessionIdFromEnv,

package/core/KENAZ_CORE_VERSION

@@ -1 +1 @@
-0.3.6
+0.3.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kenaz",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "Install Kenaz (plugin, hooks, kenaz-server) for Claude Code and Codex: npx kenaz install",
   "bin": {
     "kenaz": "bin/kenaz.js"
@@ -20,11 +20,11 @@
     "test": "node --test lib/cli.test.js"
   },
   "optionalDependencies": {
-    "@kenazai/server-darwin-arm64": "0.3.6",
-    "@kenazai/server-darwin-x64": "0.3.6",
-    "@kenazai/server-linux-arm64": "0.3.6",
-    "@kenazai/server-linux-x64": "0.3.6",
-    "@kenazai/server-win32-x64": "0.3.6"
+    "@kenazai/server-darwin-arm64": "0.3.7",
+    "@kenazai/server-darwin-x64": "0.3.7",
+    "@kenazai/server-linux-arm64": "0.3.7",
+    "@kenazai/server-linux-x64": "0.3.7",
+    "@kenazai/server-win32-x64": "0.3.7"
   },
   "license": "UNLICENSED",
   "repository": {