@kienntpixon/dieu-phoi 0.5.3 → 0.6.1

package/lib/commands.cjs

@@ -8,7 +8,8 @@ const core = require('../hook.cjs');
 const agg = require('./aggregate.cjs');
 const chooser = require('./choose.cjs');
 const setupLib = require('./setup.cjs');
-const { claudeDirOf, ctxOf, yesNo } = require('./args.cjs');
+const cbm = require('./cbm.cjs');
+const { claudeDirOf, ctxOf, yesNo, repoOf } = require('./args.cjs');
 
 const AGENT_OUTCOMES = ['pass', 'fail', 'timeout', 'aborted'];
 const USER_OUTCOMES = ['accept', 'reject'];
@@ -48,6 +49,7 @@ function table(rows) {
 // ------------------------------------------------------------------ setup / uninstall
 
 function cmdSetup(opts) {
+  if (opts['with-codebase-memory']) return cmdSetupWithCbm(opts);
   const res = setupLib.setup({
     claudeDir: claudeDirOf(opts),
     dept: typeof opts.dept === 'string' ? opts.dept : undefined,
@@ -75,6 +77,30 @@ function cmdSetup(opts) {
   return { code: 0, out: lines.join('\n') };
 }
 
+/** `setup --with-codebase-memory [--force] [--cbm-dir D]`: normal setup, then install + register codebase-memory-mcp. */
+async function cmdSetupWithCbm(opts) {
+  const base = cmdSetup(Object.assign({}, opts, { 'with-codebase-memory': false, json: false }));
+  let res;
+  let err = null;
+  try {
+    res = await cbm.install({ claudeDir: claudeDirOf(opts), force: !!opts.force, dir: typeof opts['cbm-dir'] === 'string' ? opts['cbm-dir'] : undefined, allowCustomSource: !!opts['allow-custom-source'] });
+  } catch (e) {
+    err = e.message;
+  }
+  if (opts.json) return { code: err ? 1 : 0, out: JSON.stringify({ setup: 'ok', codebase_memory: err ? { ok: false, error: err } : res }, null, 2) };
+  const lines = [base.out];
+  if (err) {
+    lines.push(`codebase-memory-mcp: LỖI — ${err} (setup dieu-phoi vẫn xong; không có gì bị ghi đè)`);
+  } else {
+    const act = { kept: 'đã có, giữ nguyên (--force để cài lại)', installed: 'đã cài', replaced: 'đã thay' }[res.action];
+    lines.push(`codebase-memory-mcp: ${act} v${res.version || '?'} tại ${res.binary.replace(/\\/g, '/')}${res.backup ? ` (bản cũ: ${path.basename(res.backup)})` : ''}`);
+    lines.push(`MCP (user scope): ${{ kept: 'đã đăng ký, giữ nguyên', 'kept-other': 'đã đăng ký (binary khác), giữ nguyên', added: 'đã đăng ký bằng `claude mcp add`', replaced: 'đã đăng ký lại', restored: 'đăng ký mới lỗi — đã khôi phục đăng ký cũ', manual: 'chưa đăng ký (xem ghi chú)' }[res.mcp]}`);
+    for (const n of res.notes) lines.push(`  - ${n}`);
+    if (res.action !== 'kept' || res.mcp === 'added' || res.mcp === 'replaced') lines.push('Khởi động lại các phiên Claude Code để nạp MCP; kiểm bằng `dieu-phoi doctor`.');
+  }
+  return { code: err ? 1 : 0, out: lines.join('\n') };
+}
+
 function cmdUninstall(opts) {
   const res = setupLib.uninstall({ claudeDir: claudeDirOf(opts), purge: !!opts.purge });
   if (opts.json) return { code: 0, out: JSON.stringify(res, null, 2) };
@@ -116,6 +142,14 @@ async function cmdDoctor(opts) {
   const sd = ctx.config.skill_dir;
   add(!!sd && fs.existsSync(path.join(sd, 'profile', 'profile.json')), 'profile',
     sd ? path.join(sd, 'profile', 'profile.json') : 'không có skill_dir — choose dùng priors mặc định', 'CẢNH BÁO');
+  // codebase-memory-mcp (optional): started here so its `daemon status` (~2.7 s, only with --cbm/--net; else a 10-minute
+  // cache) overlaps the hook-run check below
+  let cbmP = Promise.resolve([]);
+  try {
+    cbmP = cbm.doctorChecks({ claudeDir, repo: repoOf(opts), net: !!opts.net, deep: !!opts.cbm, cacheFile: path.join(ctx.paths.data, 'cbm-daemon.json') }).catch((e) => [{ ok: true, level: 'OK', name: 'codebase-memory', detail: `bỏ qua kiểm (${e.message})` }]);
+  } catch (e) {
+    cbmP = Promise.resolve([{ ok: true, level: 'OK', name: 'codebase-memory', detail: `bỏ qua kiểm (${e.message})` }]);
+  }
   if (reg.commands.length) {
     const cmd = reg.commands[0];
     const t0 = Date.now();
@@ -168,13 +202,17 @@ async function cmdDoctor(opts) {
     const cached = opts.net ? null : core.sinkStatusCached(ctx);
     if (cached && (cached.state === 'ok' || cached.state === 'fail')) {
       add(cached.state === 'ok', 'sink', `${ctx.config.sink_url} → ${cached.state === 'ok' ? 'ok' : `lỗi: ${cached.detail}`} (bộ nhớ đệm: ${cached.source} lúc ${cached.ts}; \`doctor --net\` để kiểm trực tiếp)`);
+    } else if (!opts.net && recentSinkTimeout(ctx)) {
+      const t = recentSinkTimeout(ctx);
+      add(false, 'sink', `${ctx.config.sink_url} → chậm/không xác định: lần kiểm lúc ${t.ts} không phản hồi kịp (chưa coi là lỗi); \`doctor --net\` để thử lại`, 'CẢNH BÁO');
     } else {
       const live = await checkSinkLive(ctx);
-      add(live.ok, 'sink', `${ctx.config.sink_url} → ${live.detail}`);
+      add(live.ok, 'sink', `${ctx.config.sink_url} → ${live.detail}`, live.slow ? 'CẢNH BÁO' : undefined);
     }
   } else {
     add(true, 'sink', 'chưa cấu hình (chỉ lưu cục bộ)');
   }
+  for (const c of await cbmP) checks.push(c);
   const failed = checks.some((c) => c.level === 'LỖI');
   if (opts.json) return { code: failed ? 1 : 0, out: JSON.stringify({ ok: !failed, runs_dir: reg.runs_dir, checks }, null, 2) };
   const out = checks.map((c) => `[${c.level}] ${c.name}: ${c.detail}`).join('\n');
@@ -208,26 +246,45 @@ function sweepStaleTmp(ctx) {
   return { removed, left };
 }
 
-/** Live sink check (view=stats); result cached in data/sink-check.json for 24 h. */
+/** The doctor's own timed-out sink check for the current sink, if less than 1 h old (else null): plain `doctor` does not retry a 20 s wait each time. */
+function recentSinkTimeout(ctx) {
+  const chk = core.readJsonFile(ctx.paths.sinkCheck, null);
+  if (!chk || !chk.timeout || chk.url !== core.sinkUrlKey(ctx.config)) return null;
+  const t = Date.parse(chk.ts);
+  return t && Date.now() - t < 3600 * 1000 && t <= Date.now() + 60000 ? { ts: chk.ts } : null;
+}
+
+/**
+ * Live sink check (view=stats); result cached in data/sink-check.json for 24 h. Apps Script often needs 8-15 s, so the
+ * timeout is 20 s (DIEU_PHOI_SINK_CHECK_TIMEOUT_MS overrides, for tests). A timeout is not a hard failure: it is
+ * reported as slow/unknown (CẢNH BÁO) and cached with `timeout: true`, which the cache readers ignore.
+ */
 async function checkSinkLive(ctx) {
   let ok = false;
+  let slow = false;
   let detail;
+  const ms = Number(process.env.DIEU_PHOI_SINK_CHECK_TIMEOUT_MS) > 0 ? Number(process.env.DIEU_PHOI_SINK_CHECK_TIMEOUT_MS) : 20000;
   try {
     const u = new URL(ctx.config.sink_url);
     u.searchParams.set('token', ctx.config.sink_token);
     u.searchParams.set('view', 'stats');
-    const res = await fetch(u, { redirect: 'follow', signal: AbortSignal.timeout(8000) });
+    const res = await fetch(u, { redirect: 'follow', signal: AbortSignal.timeout(ms) });
     const txt = await res.text();
     ok = res.ok;
     try { const b = JSON.parse(txt); if (b && b.ok === false) ok = false; } catch (_) { ok = false; }
     detail = `HTTP ${res.status}`;
   } catch (e) {
-    detail = e.message;
+    if (e && (e.name === 'TimeoutError' || e.name === 'AbortError')) {
+      slow = true;
+      detail = `chậm/không xác định: không phản hồi trong ${Math.round(ms / 1000)} s (Apps Script thường mất 8-15 s; chạy lại \`doctor --net\`, hoặc xem kết quả sync nền)`;
+    } else {
+      detail = e.message;
+    }
   }
   try {
-    core.writeFileAtomic(ctx.paths.sinkCheck, `${JSON.stringify({ ts: core.nowIso(), ok, detail, url: core.sinkUrlKey(ctx.config) })}\n`);
+    core.writeFileAtomic(ctx.paths.sinkCheck, `${JSON.stringify({ ts: core.nowIso(), ok, detail, url: core.sinkUrlKey(ctx.config), ...(slow ? { timeout: true } : {}) })}\n`);
   } catch (_) { /* cache is best effort */ }
-  return { ok, detail };
+  return { ok, detail, slow };
 }
 
 // ------------------------------------------------------------------ start
@@ -239,13 +296,17 @@ async function checkSinkLive(ctx) {
 function cmdStart(opts) {
   const ctx = ctxOf(opts);
   const reg = setupLib.registration(claudeDirOf(opts));
-  const info = core.startInfo(ctx);
+  const info = core.startInfo(ctx, repoOf(opts));
   const h = info.health;
   if (!fs.existsSync(ctx.paths.hook)) h.problems.unshift(`chưa cài hook (${ctx.paths.hook}) — chạy \`dieu-phoi setup --dept <phòng>\`, log không được ghi`);
   else if (!(reg.PostToolUse && reg.SubagentStop && reg.SessionStart)) h.problems.unshift('hook chưa đăng ký đủ trong settings.json — chạy lại `dieu-phoi setup`, log/trạng thái không được ghi');
   if (!reg.UserPromptSubmit) h.problems.push('thiếu hook UserPromptSubmit — chạy lại `dieu-phoi setup` để bỏ được lệnh này');
   if (!reg.permissions || reg.legacy_permissions) h.problems.push(`thiếu quyền ghi cho ${reg.permission_entries.dir} — chạy lại \`dieu-phoi setup\` (agent nền có thể không ghi được report)`);
   h.ok = !h.problems.length;
+  // core 0.6.0: project of --repo / cwd (file reads only; null outside a git repo)
+  let proj = null;
+  try { proj = core.resolveProject(repoOf(opts)); } catch (_) { /* no project */ }
+  info.project = proj ? { dir_name: proj.dir_name, key: proj.key, kind: proj.kind, dir: proj.dir, exists: proj.exists } : null;
   if (opts.json) return { code: 0, out: JSON.stringify(info, null, 2) };
   const out = [
     `root_task_id: ${info.id}`,
@@ -254,6 +315,7 @@ function cmdStart(opts) {
     `health: ${core.healthLine(h)}`,
     `scout_brief: ${info.scout_brief || '(không thấy — dùng references/brief-template.md mục E)'}`,
     ...core.orchLessonLines(info),
+    ...core.knowledgeLines(info),
   ];
   return { code: 0, out: out.join('\n') };
 }
@@ -415,11 +477,49 @@ function verdictRoot(opts, ctx, events) {
   const judged = new Set(events.filter((e) => e.kind === 'verdict' && agg.normalizeVerdict(e).by === 'user').map((e) => e.task_id));
   const gone = agg.discardedTaskIds(events);
   const todo = steps.filter((x) => execTasks.has(x.task_id) && !judged.has(x.task_id) && !gone.has(x.task_id));
-  if (!todo.length) throw new Error(`Không có bước nào của ${root} cần nghiệm thu (chưa giao exec, hoặc đã có verdict người dùng).`);
-  return todo.map((x) => ({
+  const list = todo.map((x) => ({
     step: String(x.id),
     ev: verdictUser(Object.assign({}, opts, { task: x.task_id, _: ['accept'], round: undefined, cause: undefined }), ctx, events),
   }));
+  // No step waiting is not an error by itself: the root's own and untagged deltas still need merging (cmdVerdict decides).
+  if (!list.length) list.emptyMsg = `Không có bước nào của ${root} cần nghiệm thu (chưa giao exec, hoặc đã có verdict người dùng).`;
+  return list;
+}
+
+/** Root task of a step: the approved plan that lists it, else the task itself (a loose task is its own run). */
+function rootOfTask(ctx, taskId) {
+  let files = [];
+  try { files = fs.readdirSync(ctx.paths.plans).filter((f) => f.endsWith('.json')); } catch (_) { return taskId; }
+  for (const f of files) {
+    const p = core.readJsonFile(path.join(ctx.paths.plans, f), null);
+    if (p && typeof p.root_task_id === 'string' && Array.isArray(p.steps) && p.steps.some((x) => x && x.task_id === taskId)) return p.root_task_id;
+  }
+  return taskId;
+}
+
+/**
+ * Gate 3 (core 0.6.0): a user accept merges the run's knowledge deltas of the accepted tasks
+ * (knowledge-delta-<task_id>[-r<n>].md; on --root also the root's own and untagged ones). Never fails the verdict:
+ * conflicts/rejections are reported with the command to retry. --no-knowledge skips it.
+ */
+function knowledgeOnAccept(opts, ctx, root, tasks, untagged) {
+  if (opts['no-knowledge']) return null;
+  const kn = require('./knowledge.cjs');
+  const runDir = path.join(core.runsDir(), root);
+  const filter = { tasks: new Set(tasks), untagged };
+  try {
+    if (!fs.statSync(runDir).isDirectory() || !kn.deltaFiles(runDir, filter).length) return null;
+  } catch (_) { return null; }
+  const taskArg = tasks.join(',');
+  const retry = `dieu-phoi knowledge merge --run ${root} --task ${taskArg}${untagged ? ' --untagged' : ''}`;
+  let r;
+  try {
+    r = kn.cmdMerge({ _: [], run: runDir, task: taskArg, untagged, repo: opts.repo });
+  } catch (e) {
+    return { code: 1, out: `knowledge: gộp lỗi (${e.message}) — chạy lại: ${retry}` };
+  }
+  const tail = r.code ? `\n→ có mục chưa gộp: get lại mục đó, chép dòng base: mới vào delta (hoặc bỏ mục), rồi ${retry}` : '';
+  return { code: r.code, out: `knowledge (tự gộp khi accept):\n${r.out}${tail}` };
 }
 
 function cmdVerdict(opts) {
@@ -428,14 +528,33 @@ function cmdVerdict(opts) {
   if (typeof opts.root === 'string' && typeof opts.task !== 'string') {
     const list = verdictRoot(opts, ctx, events);
     for (const x of list) core.appendEvent(ctx, x.ev);
-    if (opts.json) return { code: 0, out: JSON.stringify(list.map((x) => x.ev)) };
-    return { code: 0, out: `Đã ghi người dùng accept cho ${list.length} bước của ${opts.root}: ${list.map((x) => `${x.step}=${x.ev.task_id}`).join(', ')}.` };
+    const root = String(opts.root);
+    const kn = knowledgeOnAccept(opts, ctx, root, [root].concat(list.map((x) => x.ev.task_id)), true);
+    if (!list.length) {
+      // Every step was already judged (e.g. accepted one by one with --task): still merge the root + untagged deltas.
+      // Exit code follows the merge (0 merged or nothing new, 2 conflict or reject, 1 error); no delta at all keeps the old "nothing to do" error.
+      if (!kn) throw new Error(list.emptyMsg);
+      const msg = `Không còn bước nào của ${root} chờ nghiệm thu; chỉ gộp delta của root và delta không thẻ.`;
+      if (opts.json) { process.stderr.write(`${msg}\n${kn.out}\n`); return { code: kn.code, out: '[]' }; }
+      return { code: kn.code, out: `${msg}\n${kn.out}` };
+    }
+    if (opts.json) {
+      if (kn) process.stderr.write(`${kn.out}\n`);
+      return { code: 0, out: JSON.stringify(list.map((x) => x.ev)) };
+    }
+    const msg = `Đã ghi người dùng accept cho ${list.length} bước của ${opts.root}: ${list.map((x) => `${x.step}=${x.ev.task_id}`).join(', ')}.`;
+    return { code: 0, out: kn ? `${msg}\n${kn.out}` : msg };
   }
   const ev = typeof opts.task === 'string' ? verdictUser(opts, ctx, events) : verdictAgent(opts, ctx, events);
   core.appendEvent(ctx, ev);
-  if (opts.json) return { code: 0, out: JSON.stringify(ev) };
+  const kn = ev.by === 'user' && ev.outcome === 'accept' ? knowledgeOnAccept(opts, ctx, rootOfTask(ctx, ev.task_id), [ev.task_id], false) : null;
+  if (opts.json) {
+    if (kn) process.stderr.write(`${kn.out}\n`);
+    return { code: 0, out: JSON.stringify(ev) };
+  }
   if (ev.by === 'user') {
-    return { code: 0, out: `Đã ghi người dùng ${ev.outcome}${ev.cause ? ` (${ev.cause})` : ''} cho task ${ev.task_id}, vòng ${ev.round}.` };
+    const msg = `Đã ghi người dùng ${ev.outcome}${ev.cause ? ` (${ev.cause})` : ''} cho task ${ev.task_id}, vòng ${ev.round}.`;
+    return { code: 0, out: kn ? `${msg}\n${kn.out}` : msg };
   }
   return { code: 0, out: `Đã ghi ${ev.outcome} cho ${ev.agent_id}${ev.task_id ? ` (task ${ev.task_id})` : ''}.` };
 }
@@ -553,17 +672,21 @@ function ctxWarnOnce(ctx, m) {
   const file = path.join(ctx.paths.data, 'ctx-warn.json');
   const level = ctxWarnLevel(m.ctx_growth, m.soft_cap);
   try {
-    const st = core.readJsonFile(file, {}) || {};
-    const cur = st[m.session_id];
-    const comp = typeof m.compactions === 'number' ? m.compactions : null;
-    const warn = !cur || cur.compactions !== comp || level > (Number(cur.level) || 0);
-    if (warn) {
-      const now = Date.now();
-      st[m.session_id] = { level, compactions: comp, t: now };
-      for (const k of Object.keys(st)) if (!(now - Number(st[k] && st[k].t) < CTX_WARN_KEEP_MS)) delete st[k];
-      core.writeFileAtomic(file, `${JSON.stringify(st)}\n`);
-    }
-    return warn;
+    // Core 0.5.4: read-modify-write under ctx-warn.lock — two sessions warning at once no longer overwrite each
+    // other's entry (a lost entry made the warning repeat). Lock timeout => go on unlocked (state is advisory).
+    return core.withFileLock(ctx.paths.ctxWarnLock, { timeoutMs: 2000, staleMs: 15000 }, () => {
+      const st = core.readJsonFile(file, {}) || {};
+      const cur = st[m.session_id];
+      const comp = typeof m.compactions === 'number' ? m.compactions : null;
+      const warn = !cur || cur.compactions !== comp || level > (Number(cur.level) || 0);
+      if (warn) {
+        const now = Date.now();
+        st[m.session_id] = { level, compactions: comp, t: now };
+        for (const k of Object.keys(st)) if (!(now - Number(st[k] && st[k].t) < CTX_WARN_KEEP_MS)) delete st[k];
+        core.writeFileAtomic(file, `${JSON.stringify(st)}\n`);
+      }
+      return warn;
+    }).value;
   } catch (_) {
     return true;
   }
@@ -1071,6 +1194,6 @@ function cmdPlanTable(opts) {
 }
 
 module.exports = {
-  cmdSetup, cmdUninstall, cmdDoctor, cmdStart, checkSinkLive, cmdHook, cmdSync, cmdVerdict, cmdSteer, cmdDiscard, ctxWarnOnce, ctxWarnLevel, sweepStaleTmp, planOverrideEvents, recordPlanSuggestions, cmdStats, cmdRetro, cmdPrune: (o) => require('./prune.cjs').cmdPrune(o), cmdChoose, cmdCtx, cmdState, measureOrch,
+  skillDirOf, cmdSetup, cmdUninstall, cmdDoctor, cmdStart, checkSinkLive, cmdHook, cmdSync, cmdVerdict, cmdSteer, cmdDiscard, ctxWarnOnce, ctxWarnLevel, sweepStaleTmp, planOverrideEvents, recordPlanSuggestions, cmdStats, cmdRetro, cmdPrune: (o) => require('./prune.cjs').cmdPrune(o), cmdChoose, cmdCtx, cmdState, measureOrch,
   cmdPlanTable, cmdNewId, requireTaskId, buildPlanTable, recordApprovedPlan, planTaskIdProblems, criticalPath, resolveAgentId, AGENT_OUTCOMES, USER_OUTCOMES, VERIFY,
 };