@kienntpixon/dieu-phoi 0.6.1 → 0.7.1

package/lib/knowledge.cjs

@@ -14,6 +14,7 @@
 //
 // Delta (written by agents into a run dir as knowledge-delta*.md, merged at gate 3):
 //   repo: <path of the repo/worktree the delta was checked against>   (header, before the first `## `)
+//         or a short name (`pff-tailor`) that matches exactly one known store (its name / dir name / a recorded root)
 //   head: <sha>                                                         (optional; else HEAD read from repo:)
 //   ## +<id>        new section          ## <id>     replace an existing one
 //   title: / tags: a, b / paths: glob, glob / base: <sha>#<rev>   (meta lines right under the heading)
@@ -27,7 +28,6 @@
 const fs = require('fs');
 const path = require('path');
 const cp = require('child_process');
-const crypto = require('crypto');
 const core = require('../hook.cjs');
 const { repoOf } = require('./args.cjs');
 
@@ -55,7 +55,8 @@ const KNOWLEDGE_HELP = `Cách dùng: dieu-phoi knowledge <lệnh> [--repo <đư
   merge --run <id|thư mục run> [--task <id>[,<id>] [--untagged]] [--dry-run] [--json]
                          gộp mọi knowledge-delta*.md của run (--task: chỉ knowledge-delta-<task_id>[-r<n>].md của các
                          task đó, --untagged: thêm file không mang task_id; verdict accept tự gọi bước này) vào kho của repo ghi ở header "repo:" (không có thì
-                         --repo/cwd): khoá knowledge.lock, ghi tmp+rename, bản cũ vào history/, sha = HEAD của repo đó.
+                         --repo/cwd; "repo:" là tên ngắn như pff-tailor thì khớp kho đã biết nếu duy nhất — HEAD lấy từ repo đã ghi
+                         nhớ (meta.json roots), --repo hoặc dòng head:): khoá knowledge.lock, ghi tmp+rename, bản cũ vào history/, sha = HEAD của repo đó.
                          "## +id" thêm mục (bắt buộc paths:), "## id" thay mục (bắt buộc base: <sha>#<rev>); base cũ
                          → xung đột, không ghi đè; mục > 40 dòng bị từ chối. Có xung đột/từ chối → exit 2.
                          Idempotent: file delta đã gộp (hash trong meta.json) và mục trùng một rev cũ trong history/ → "không đổi"
@@ -609,8 +610,25 @@ function sameContent(cur, body, next) {
 const APPLIED_MAX = 300;
 
 /** sha256 of the delta text, BOM and CRLF normalised so a CRLF checkout hashes like the LF original. */
-function deltaHash(text) {
-  return crypto.createHash('sha256').update(String(text).replace(/^/, '').replace(/\r\n?/g, '\n')).digest('hex');
+const deltaHash = core.deltaHash; // shared with the unmerged-delta scan in hook.cjs
+
+/** Main checkout of the repo `info` describes (a linked worktree is deleted later; the checkout stays). */
+function mainRootOf(info) {
+  const common = info && info.common_dir ? String(info.common_dir) : '';
+  if (common && path.basename(common) === '.git') return slash(path.dirname(common));
+  return info && info.root ? slash(info.root) : null;
+}
+
+/** Remember where a store's repo lives (meta.json `roots`, newest first, <= 5) so a bare `repo: <name>` can find HEAD. */
+function noteRoot(dir, info) {
+  const root = mainRootOf(info);
+  if (!root || !isDir(dir)) return;
+  const file = path.join(dir, 'meta.json');
+  const meta = core.readJsonFile(file, {}) || {};
+  const roots = Array.isArray(meta.roots) ? meta.roots : [];
+  if (roots[0] === root) return;
+  const next = [root].concat(roots.filter((r) => r !== root)).slice(0, 5);
+  core.writeFileAtomic(file, `${JSON.stringify(Object.assign({}, meta, { roots: next }), null, 2)}\n`);
 }
 
 function appliedOf(dir) {
@@ -741,9 +759,11 @@ function applyDelta(delta, info, sha, dry, src) {
     core.writeFileAtomic(path.join(dir, 'index.json'), `${JSON.stringify(idx, null, 2)}\n`);
     ensureMeta(dir, info);
   }
-  if (changed && !dry && src && !results.some((r) => r.op === 'conflict' || r.op === 'reject')) {
+  if (!dry && src && isDir(dir) && !results.some((r) => r.op === 'conflict' || r.op === 'reject')) {
+    // also when every section was already merged ("same"): the file counts as handled, not as an unmerged delta
     recordApplied(dir, info, { sha256: src.hash, file: src.file, run: src.run, at: now.toISOString() });
   }
+  if (!dry && changed && info.common_dir) noteRoot(dir, info);
   return { results };
 }
 
@@ -766,6 +786,45 @@ function describe(r) {
   return `${OP_MARK[r.op] || '?'} ${r.id} BỊ TỪ CHỐI: ${r.why}`;
 }
 
+/**
+ * Where a delta goes: { target, info } — target = repo dir to read HEAD from (null when only the store is known),
+ * info = project identity (resolveProject, or the bare store entry for a short `repo:` name). Order: a short name that
+ * matches exactly one known store, then the path, then --repo as the fallback for a repo that no longer exists.
+ */
+function targetOf(delta, opts, rep) {
+  const err = (error) => ({ error });
+  if (!delta.repo) return finish(repoOf(opts));
+  if (core.isBareRepoName(delta.repo)) {
+    const hit = core.storeByName(delta.repo);
+    if (hit.matches.length > 1) {
+      return err(`repo: ${delta.repo} khớp ${hit.matches.length} kho (${hit.matches.map((m) => m.dir_name).join(', ')}) — ghi đường dẫn đầy đủ hoặc chạy với --repo`);
+    }
+    if (hit.store) {
+      const st = hit.store;
+      rep.note = `repo: ${delta.repo} → kho ${st.dir_name}`;
+      const cands = st.roots.map((r) => core.nativePath(r)).concat(opts.repo !== undefined ? [repoOf(opts)] : []);
+      for (const c of cands) {
+        if (!isDir(c)) continue;
+        const pi = core.resolveProject(c);
+        if (pi && pi.dir === st.dir) return { target: path.resolve(c), info: pi };
+      }
+      return { target: null, info: { dir: st.dir, dir_name: st.dir_name, key: st.key, name: st.name } };
+    }
+  }
+  if (delta.repo) {
+    const p = path.resolve(core.nativePath(delta.repo));
+    if (isDir(p)) return finish(p);
+    if (opts.repo !== undefined) { rep.note = `repo: ${delta.repo} không còn — dùng --repo`; return finish(repoOf(opts)); }
+    const bare = core.isBareRepoName(delta.repo);
+    return err(`repo: ${delta.repo} ${bare ? 'không khớp kho nào đã biết và không phải thư mục' : 'không tồn tại (worktree đã xoá?)'} — chạy lại với --repo <đường dẫn repo>`);
+  }
+  return err('không xác định được repo');
+  function finish(target) {
+    const info = core.resolveProject(target);
+    return info ? { target, info } : err(`không phải repo git: ${slash(target)}`);
+  }
+}
+
 function cmdMerge(opts) {
   const rd = runDirOf(opts.run);
   if (rd.error) return { code: 1, out: rd.error };
@@ -786,23 +845,20 @@ function cmdMerge(opts) {
       src = { hash: deltaHash(text), file: path.basename(file), run: path.basename(rd.dir) };
     } catch (e) { rep.error = `không đọc được: ${e.message}`; totals.error++; continue; }
     if (!delta.sections.length) { rep.error = 'không có mục "## <id>" nào'; totals.error++; continue; }
-    let target = null;
-    if (delta.repo) {
-      const p = path.resolve(core.nativePath(delta.repo));
-      if (isDir(p)) target = p;
-      else if (opts.repo !== undefined) { target = repoOf(opts); rep.note = `repo: ${delta.repo} không còn — dùng --repo`; } else {
-        rep.error = `repo: ${delta.repo} không tồn tại (worktree đã xoá?) — chạy lại với --repo <đường dẫn repo>`; totals.error++; continue;
-      }
-    } else target = repoOf(opts);
-    const info = core.resolveProject(target);
-    if (!info) { rep.error = `không phải repo git: ${slash(target)}`; totals.error++; continue; }
+    const t = targetOf(delta, opts, rep);
+    if (t.error) { rep.error = t.error; totals.error++; continue; }
+    const { target, info } = t;
     let sha = null;
     if (delta.head) {
       if (!/^[0-9a-f]{7,64}$/i.test(delta.head)) { rep.error = `head: không phải sha: ${delta.head}`; totals.error++; continue; }
       sha = delta.head.toLowerCase();
-    } else sha = headShaOf(target);
-    if (!sha) { rep.error = `không xác định được HEAD của ${slash(target)} (repo chưa có commit?) — thêm dòng "head: <sha>" vào delta`; totals.error++; continue; }
-    Object.assign(rep, { repo: slash(target), store: info.dir, key: info.key, sha });
+    } else if (target) sha = headShaOf(target);
+    if (!sha) {
+      rep.error = target ? `không xác định được HEAD của ${slash(target)} (repo chưa có commit?) — thêm dòng "head: <sha>" vào delta`
+        : `repo: ${delta.repo} khớp kho ${info.dir_name} nhưng chưa biết repo nằm đâu để đọc HEAD — thêm dòng "head: <sha>" vào delta hoặc chạy với --repo <đường dẫn repo>`;
+      totals.error++; continue;
+    }
+    Object.assign(rep, { repo: target ? slash(target) : null, store: info.dir, key: info.key, sha });
     let out;
     if (dry) out = applyDelta(delta, info, sha, true, src);
     else {

package/lib/setup.cjs

@@ -57,7 +57,11 @@ function stripOurHooks(settings) {
   return removed;
 }
 
-/** True when settings already hold exactly our four entries with this command. */
+// core 0.7.1: the subagent tool is `Agent` in current Claude Code and `Task` in older builds — match both
+// (an old `Agent`-only registration is not "already registered", so `setup` rewrites it).
+const AGENT_MATCHER = 'Agent|Task';
+
+/** True when settings already hold exactly our five entries with this command. */
 function alreadyRegistered(settings, cmd) {
   const hooks = settings && settings.hooks;
   if (!hooks || typeof hooks !== 'object') return false;
@@ -69,14 +73,15 @@ function alreadyRegistered(settings, cmd) {
         if (!isOurs(h)) continue;
         ours++;
         if (h.command !== cmd) continue;
-        if (event === 'PostToolUse' && g.matcher === 'Agent') good++;
+        if (event === 'PostToolUse' && g.matcher === AGENT_MATCHER) good++;
         else if (event === 'SubagentStop') good++;
         else if (event === 'SessionStart' && g.matcher === 'compact') good++;
         else if (event === 'UserPromptSubmit' && !g.matcher) good++;
+        else if (event === 'PreToolUse' && g.matcher === AGENT_MATCHER) good++;
       }
     }
   }
-  return ours === 4 && good === 4;
+  return ours === 5 && good === 5;
 }
 
 function addOurHooks(settings, hookPath) {
@@ -84,7 +89,7 @@ function addOurHooks(settings, hookPath) {
   if (!settings.hooks || typeof settings.hooks !== 'object') settings.hooks = {};
   const h = settings.hooks;
   if (!Array.isArray(h.PostToolUse)) h.PostToolUse = [];
-  h.PostToolUse.push({ matcher: 'Agent', hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
+  h.PostToolUse.push({ matcher: AGENT_MATCHER, hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
   if (!Array.isArray(h.SubagentStop)) h.SubagentStop = [];
   h.SubagentStop.push({ hooks: [{ type: 'command', command: cmd, timeout: 10 }] });
   // after /compact or auto-compact: re-inject the orchestration state rebuilt from the log
@@ -93,6 +98,9 @@ function addOurHooks(settings, hookPath) {
   // on a dieu-phoi prompt: pre-create the run dir + id so the first tool call can be the scout (no shell)
   if (!Array.isArray(h.UserPromptSubmit)) h.UserPromptSubmit = [];
   h.UserPromptSubmit.push({ hooks: [{ type: 'command', command: cmd, timeout: 5 }] });
+  // core 0.7.1 (C1): deny another exec continuation of a task that already handed off 3 times (unless chain_ok)
+  if (!Array.isArray(h.PreToolUse)) h.PreToolUse = [];
+  h.PreToolUse.push({ matcher: AGENT_MATCHER, hooks: [{ type: 'command', command: cmd, timeout: 5 }] });
 }
 
 // ------------------------------------------------------------------ run-dir permissions
@@ -413,7 +421,7 @@ function registration(claudeDir) {
   const perms = permissionEntries(runsDir());
   const legacy = permissionEntries(legacyRunsDirOf(claudeDir));
   const out = {
-    file, PostToolUse: false, SubagentStop: false, SessionStart: false, UserPromptSubmit: false, commands: [], permissions: false, permission_entries: perms,
+    file, PostToolUse: false, SubagentStop: false, SessionStart: false, UserPromptSubmit: false, PreToolUse: false, commands: [], permissions: false, permission_entries: perms,
     runs_dir: perms.dir, runs_dir_exists: fs.existsSync(perms.dir), legacy_permissions: false,
   };
   let obj;
@@ -423,11 +431,11 @@ function registration(claudeDir) {
   out.legacy_permissions = legacy.allow.some((r) => Array.isArray(lp.allow) && lp.allow.includes(r))
     || (Array.isArray(lp.additionalDirectories) && lp.additionalDirectories.includes(legacy.dir));
   const hooks = obj.hooks || {};
-  for (const ev of ['PostToolUse', 'SubagentStop', 'SessionStart', 'UserPromptSubmit']) {
+  for (const ev of ['PostToolUse', 'SubagentStop', 'SessionStart', 'UserPromptSubmit', 'PreToolUse']) {
     for (const g of Array.isArray(hooks[ev]) ? hooks[ev] : []) {
       for (const h of (g && Array.isArray(g.hooks) ? g.hooks : [])) {
         if (!isOurs(h)) continue;
-        if (ev === 'PostToolUse' && g.matcher && !/\bAgent\b/.test(g.matcher)) continue;
+        if ((ev === 'PostToolUse' || ev === 'PreToolUse') && g.matcher && !/\b(Agent|Task)\b/.test(g.matcher)) continue;
         if (ev === 'SessionStart' && g.matcher !== 'compact') continue;
         out[ev] = true;
         out.commands.push(h.command);
@@ -438,6 +446,6 @@ function registration(claudeDir) {
 }
 
 module.exports = {
-  MARKER, AGENT_NAMES, AGENT_MARKER, renderAgent, agentStatus, nodePathOf, installAgents, removeAgents, agentsDirOf, setup, uninstall, registration, stripOurHooks, addOurHooks, alreadyRegistered, hookCommand,
+  MARKER, AGENT_NAMES, AGENT_MARKER, renderAgent, agentStatus, nodePathOf, installAgents, removeAgents, agentsDirOf, setup, uninstall, registration, stripOurHooks, addOurHooks, alreadyRegistered, hookCommand, AGENT_MATCHER,
   skillVersionOf, findSkillDir, tsStamp, runsDir, legacyRunsDirOf, permissionEntries, addOurPermissions, stripOurPermissions, hasOurPermissions,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kienntpixon/dieu-phoi",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Hook + CLI ghi log subagent của Claude Code và chọn model/effort theo chi phí + thời gian tới lúc nghiệm thu.",
   "license": "MIT",
   "author": "kiennt <kiennt@pixon.games>",