@nanonets/graft 0.24.0 → 0.25.0

package/dist/claude/hooks.js

@@ -1,44 +1,49 @@
 import { readFileSync, existsSync } from 'node:fs';
-import { execFileSync, spawn } from 'node:child_process';
+import { execFileSync } from 'node:child_process';
 import { join, basename, isAbsolute, relative, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { readWiring } from './stats.js';
-import { formatBlastRadius, relevantRetrieval, formatOrientation, notesForPrompt, notesOnTouch, standingDirective } from './format.js';
+import { formatBlastRadius, formatOrientation, notesOnTouch, standingDirective, teamNotesDirective } from './format.js';
 import { commitLines, listNotes, setupCommitLine, standingLearnings } from '../notes/notes.js';
 import { liveLearnings } from '../notes/learning-fields.js';
 import { noteAuthor, teammatesOn } from '../notes/git-facts.js';
 import { indexFreshness, staleBanner } from '../context/check.js';
-import { patchStats, readStats, acquireLock, readSession, writeSession, resolveContextDir } from './state.js';
-import { graftCliPath, claudeScriptPath } from './paths.js';
+import { dropStoredPrompts, patchStats, readSession, writeSession, resolveContextDir } from './state.js';
+import { emit, emitHook, graftJson, payloadSessionId, withContextDirArg } from './hook-io.js';
+import { codexPostBashPart, postBashPart, sessionStartPart } from './skills-wiring.js';
+import { handlePrompt } from './prompt-hook.js';
 import { runUpkeep } from '../upkeep-run.js';
 import { runningVersion, wiredHostIds } from '../upkeep.js';
 import { hostsWiredForTrail } from '../hosts/registry.js';
 import { flushClosedSessions, summarizeSession } from '../telemetry/sessions.js';
 import { maybeFlushInBackground } from '../telemetry/flush.js';
-import { hasSavingsTally, lastAssistantTurn, lastTurnBilling } from './tally.js';
-import { scopeOf, scopesOfGraph } from '../graph/scopes.js';
+import { handleStopEvent } from './stop.js';
+import { main as preBashMain } from './pre-bash.js';
 import { classifyToolUse, commandInvokesGraft, isMcpToolName, isGraftMcpTool, parseSavings, recordToolUse } from './session-metrics.js';
-import { adoptRepoBrand, brand, cmd, commandOnPath, repoWiredForTrail, tag, trailHandoverLine, trailOnPath } from '../brand.js';
+import { adoptRepoBrand, brand, commandOnPath, repoWiredForTrail, tag, trailHandoverLine, trailOnPath } from '../brand.js';
 import { fitTrailServerToMachine } from '../hosts/claude-global.js';
 import { globalCopyCovers } from './hook-layers.js';
-import { NOTE_ASKS_PER_SESSION, noteAsk, noteSignals } from './note-signals.js';
-import { keepsNotes, noteCount, repoPlace } from '../notes/home.js';
+import { keepsNotes, noteCounts, repoPlace } from '../notes/home.js';
 import { branchesStale, overlapMark, readBranchCache, refreshBranches, SESSION_REFRESH_MS } from '../notes/branches.js';
 import { learningFiles } from '../notes/repo-trail.js';
 import { inWorkspace, maybeSyncInBackground } from '../cloud/workspace-sync.js';
 import { cacheDir, readJson, writeJsonAtomic } from '../util/state.js';
 import { countBucket } from '../telemetry/contract.js';
+import { detectHost } from '../trace/host.js';
 import { track } from '../telemetry/track.js';
 import { skillsDirective } from '../skills/skills.js';
-/** Prompts shorter than this never trigger retrieval — they are almost always
- * conversational ("yes go ahead", "thanks") and the coverage gate can't judge
- * them reliably with so few terms. */
-const MIN_PROMPT_CHARS = 12;
+import { everyRepoLearnings } from '../notes/every-repo.js';
+import { hostFacts } from '../skills/host-facts.js';
+import { trailNow } from '../skills/settings.js';
+import { recordSkillUse, skillOfToolUse } from './skill-use.js';
+import { keptContext, keptNotice } from './start-init.js';
+export { lastFileScopeHint, promptAskTimeout } from './prompt-hook.js';
 function readStdin() {
     const seam = process.env.GRAFT_TEST_STDIN;
     const raw = seam !== undefined ? seam : safeReadFd0();
     try {
-        return JSON.parse(raw);
+        const input = JSON.parse(raw);
+        return input && typeof input === 'object' && !Array.isArray(input) ? input : {};
     }
     catch {
         return {};
@@ -58,132 +63,11 @@ export function underGraft(dir, file) {
     const posix = rel.replace(/^[/\\]+/, '').replace(/\\/g, '/');
     return posix.startsWith('graft/') || posix.startsWith('.trail/cache/');
 }
-/** Default budget for a graft child process invoked from a hook, matching the 8s
- * the installed hook entries carry. */
-const CHILD_TIMEOUT_MS = 8000;
-/** Headroom left for the hook's own work (read stdin, score, write session, emit)
- * after its `graft ask` child returns. */
-const HOOK_OVERHEAD_MS = 2000;
-/** Floor, so a hand-edited tiny timeout can't leave the child no time at all. */
-const MIN_CHILD_TIMEOUT_MS = 4000;
-/**
- * How long the prompt hook may let `graft ask` run — derived from the budget that is
- * *actually installed* in this repo's `.claude/settings.json`, not from what the
- * current version of `settings-merge.ts` would install.
- *
- * A query now brings the graph up to date first, so `graft init` raises the
- * UserPromptSubmit budget to 15s to cover the one cold rebuild after an upgrade. But
- * `mergeGraftSettings` only runs during `graft init` — upgrading the npm package does
- * not re-run it. So every repo wired before that change keeps `"timeout": 8000`, and
- * hard-coding a 13s child there means Claude Code kills the hook first: `emit()` and
- * `writeSession()` never run, the turn gets no retrieval pack at all, and the SIGKILLed
- * child can't even release the build lock. Reading the installed number keeps the child
- * strictly inside whatever budget this repo really has.
- */
-export function promptAskTimeout(dir) {
-    const installed = installedHookTimeout(dir, 'UserPromptSubmit');
-    if (installed === null)
-        return CHILD_TIMEOUT_MS - HOOK_OVERHEAD_MS;
-    return Math.max(MIN_CHILD_TIMEOUT_MS, installed - HOOK_OVERHEAD_MS);
-}
-/**
- * Every settings file Claude Code merges hook definitions from, for a session
- * rooted at `dir`. The per-repo file is not the only place graft's hooks can be
- * installed: declaring them once at the user level wires every repo on the
- * machine at once, and such a repo has no `.claude/settings.json` at all.
- */
-function hookSettingsFiles(dir) {
-    const user = process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), '.claude');
-    return [
-        join(dir, '.claude', 'settings.json'),
-        join(dir, '.claude', 'settings.local.json'),
-        join(user, 'settings.json'),
-    ];
-}
-/** The timeout on one settings file's graft hook entry for `event`, or null if it
- * can't be read (no settings file, hand-edited shape, unparseable JSON). */
-function hookTimeoutIn(file, event) {
-    try {
-        const settings = JSON.parse(readFileSync(file, 'utf8'));
-        const blocks = settings?.hooks?.[event];
-        if (!Array.isArray(blocks))
-            return null;
-        for (const block of blocks) {
-            for (const h of block?.hooks ?? []) {
-                if (typeof h?.command === 'string' && /(graft|trail)-hooks\.cjs/.test(h.command) && typeof h.timeout === 'number') {
-                    return h.timeout;
-                }
-            }
-        }
-        return null;
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * The budget this hook is actually running under, or null when no settings file
- * declares one.
- *
- * The smallest declared timeout wins rather than the nearest, because when more
- * than one file declares the hook Claude Code runs every matching entry and this
- * process cannot tell which one launched it. Guessing high is the expensive
- * mistake: an overrunning child gets the whole hook SIGKILLed, so `emit()` and
- * `writeSession()` never run and the turn silently gets no retrieval at all.
- * Guessing low only shortens one query.
- */
-function installedHookTimeout(dir, event) {
-    let smallest = null;
-    for (const file of hookSettingsFiles(dir)) {
-        const timeout = hookTimeoutIn(file, event);
-        if (timeout === null)
-            continue;
-        if (smallest === null || timeout < smallest)
-            smallest = timeout;
-    }
-    return smallest;
-}
-/**
- * Append `--dir <contextDir>` for the hooks' own `graft ask`/`graft check`
- * children — the one place in this file that spawns the CLI itself rather
- * than reading `graft/` off disk (which already resolves through
- * `resolveContextDir` inside `util/state.ts` and `claude/stats.ts`). A no-op
- * when `GRAFT_DIR` isn't set, so an unconfigured repo's spawned CLI sees
- * byte-identical argv to before this existed.
- */
-function withContextDirArg(dir, args) {
-    return process.env.GRAFT_DIR ? [...args, '--dir', resolveContextDir(dir)] : args;
-}
-function graftJson(dir, args, timeout = CHILD_TIMEOUT_MS) {
-    try {
-        // GRAFT_TEST_CLI is a test seam (mirrors GRAFT_TEST_STDIN/GRAFT_TEST_SYNC_RUN) so
-        // tests can point the prompt hook's `graft ask`/`graft check` calls at a stub
-        // script and observe the exact args it was invoked with, instead of shelling
-        // out to the real CLI (which isn't built relative to the TS source under test).
-        const cliPath = process.env.GRAFT_TEST_CLI ?? graftCliPath();
-        const out = execFileSync(process.execPath, [cliPath, ...args], { cwd: dir, encoding: 'utf8', timeout, stdio: ['ignore', 'pipe', 'ignore'], windowsHide: true });
-        return JSON.parse(out);
-    }
-    catch (e) {
-        // `graft check` exits non-zero when the graph is stale (by design) but still
-        // prints valid JSON to stdout; recover it from the thrown error before giving up.
-        if (e && typeof e.stdout === 'string' && e.stdout.trim()) {
-            try {
-                return JSON.parse(e.stdout);
-            }
-            catch { /* not JSON — fall through */ }
-        }
-        return null;
-    }
-}
 function checkStaleCount(dir) {
     const r = graftJson(dir, withContextDirArg(dir, ['check', '.', '--json']));
     const g = r?.graph ?? {};
     return (g.changed?.length ?? 0) + (g.added?.length ?? 0) + (g.removed?.length ?? 0);
 }
-function emit(eventName, additionalContext) {
-    process.stdout.write(JSON.stringify({ hookSpecificOutput: { hookEventName: eventName, additionalContext } }));
-}
 /**
  * The absolute path of the file a PostToolUse edit touched, across host edit-tool
  * shapes:
@@ -264,49 +148,6 @@ async function editOverlap(input, dir, file) {
         return null;
     }
 }
-/**
- * The "you're working in backend/, weight it" hint: on a multi-scope repo,
- * narrow the prompt hook's `ask` call to whatever scope the last-edited file
- * (`stats.lastFile`, captured at {@link handlePostEdit}) sits in.
- *
- * `lastFile` is only a basename (not a repo-relative path — see
- * `handlePostEdit`), so this is a best-effort lookup against the CURRENT
- * graph: any file node whose path ends in `/<lastFile>` (or equals it, for a
- * repo-root file). Fails soft in every direction a hook must never crash on —
- * no graph, a single-scope graph, a lastFile no longer in the graph (moved,
- * deleted, or edited before the first build), or a basename that lands in
- * more than one scope (ambiguous: could be either sub-project) all skip the
- * hint silently, logging one line to stderr so the miss is visible without
- * ever failing the hook.
- */
-export function lastFileScopeHint(dir, lastFile) {
-    if (!lastFile)
-        return null;
-    try {
-        const w = readWiring(dir);
-        if (!w)
-            return null;
-        const scopes = scopesOfGraph(w);
-        if (scopes.length <= 1)
-            return null; // single-scope: no hint, no --in
-        const matches = (w.nodes ?? []).filter((n) => n.kind === 'file' && (n.path === lastFile || n.path.endsWith(`/${lastFile}`)));
-        if (matches.length === 0) {
-            console.error(`${tag()} prompt hook: lastFile "${lastFile}" not found in the graph — skipping scope hint`);
-            return null;
-        }
-        const prefixes = new Set(matches.map((n) => scopeOf(n.path, scopes).prefix));
-        if (prefixes.size > 1) {
-            console.error(`${tag()} prompt hook: lastFile "${lastFile}" matches more than one scope — skipping scope hint`);
-            return null;
-        }
-        const [prefix] = prefixes;
-        return prefix === '' ? null : prefix; // root scope: nothing to narrow
-    }
-    catch (e) {
-        console.error(`${tag()} prompt hook: scope hint lookup failed (${e?.message ?? e}) — skipping`);
-        return null;
-    }
-}
 /**
  * PostToolUse on a retrieval tool. Two jobs, both a pure parse of the payload the
  * hook already received (no re-run):
@@ -327,10 +168,7 @@ export function lastFileScopeHint(dir, lastFile) {
  * nothing is written.
  */
 function handleToolUse(input, dir) {
-    recordToolUse(dir, input?.session_id || 'default', { ...classifyAndScore(input?.tool_name, input?.tool_input?.command, () => input?.tool_response ?? input), host: 'claude-code' });
-    const learned = learningsOnTouch(input, dir);
-    if (learned)
-        emit('PostToolUse', learned);
+    recordToolUse(dir, payloadSessionId(input), { ...classifyAndScore(input?.tool_name, input?.tool_input?.command, () => input?.tool_response ?? input), host: telemetryHost(input) });
 }
 /**
  * Under trail, the learnings about the file a Read, Edit or Write just touched,
@@ -359,7 +197,7 @@ export function learningsOnTouch(input, dir) {
         const notes = liveLearnings(listNotes(dir, { branches: false }));
         if (!notes.length)
             return null;
-        const id = input?.session_id || 'default';
+        const id = payloadSessionId(input);
         const s = readSession(dir, id);
         const text = notesOnTouch(notes, touch, s);
         if (text)
@@ -371,6 +209,24 @@ export function learningsOnTouch(input, dir) {
         return null;
     }
 }
+/**
+ * PostToolUse's one answer: the skills part's, with the learnings about what
+ * the call touched added to its context. Two JSON objects on stdout would be
+ * read as neither. A block is the whole answer, so then no learning is used up.
+ */
+export function withTouchLearnings(out, input, dir) {
+    if (out.block)
+        return out;
+    const learned = learningsOnTouch(input, dir);
+    if (!learned)
+        return out;
+    return { ...out, context: [out.context, learned].filter(Boolean).join('\n\n') };
+}
+/** Who to put a tool use down to: Cursor and Copilot CLI run these hooks too. */
+function telemetryHost(input) {
+    const host = detectHost(input).host;
+    return host === 'cursor' || host === 'copilot' ? host : 'claude-code';
+}
 /**
  * Classify a tool use and, only when it could carry a graft footer, parse the
  * savings out of its (lazily-serialised) output.
@@ -422,118 +278,7 @@ function handleCursorMcp(input, dir) {
 }
 /** Cursor keys a chat by `conversation_id` (its `session_id` equivalent). */
 function cursorSessionId(input) {
-    return input?.conversation_id || input?.session_id || 'default';
-}
-/**
- * At turn end: what did this turn's input tokens actually cost?
- *
- * Deliberately ungated, unlike {@link countTallyTurn}: the blended rate has to
- * describe the session, and graft turns are not a fair sample of it — they are
- * the long, tool-heavy, cache-warm ones. Sampling only those would report a
- * cheaper token than the session really pays.
- *
- * Accumulates the pair, never the ratio, so the rate re-blends every turn. A
- * turn already billed (a duplicate Stop, or a Stop racing the transcript write)
- * is skipped on its uuid.
- */
-function sampleTurnCost(input, dir) {
-    try {
-        const id = input?.session_id || 'default';
-        const billing = lastTurnBilling(input?.transcript_path);
-        if (!billing)
-            return;
-        const s = readSession(dir, id);
-        if (billing.uuid === s.lastBillingUuid)
-            return;
-        s.inputCostMicros = (s.inputCostMicros ?? 0) + billing.costMicros;
-        s.inputTokensBilled = (s.inputTokensBilled ?? 0) + billing.tokens;
-        s.lastBillingUuid = billing.uuid;
-        writeSession(dir, id, s);
-    }
-    catch {
-        // A billing estimate is never worth failing the graph sync over.
-    }
-}
-/**
- * At turn end: did the reply the user just read say what graft saved?
- *
- * Runs only on turns the tool-savings hook flagged, so a conversational turn
- * costs nothing. A turn we cannot observe — a host whose Stop hook names no
- * transcript, an unreadable file, or a Stop that fires before the final prose
- * is on disk — is counted in NEITHER total: the ratio these two numbers form
- * has to mean "of the turns we could check", not "of the turns we tried to".
- */
-function countTallyTurn(input, dir) {
-    try {
-        const id = input?.session_id || 'default';
-        const s = readSession(dir, id);
-        if (!s.turnUsedGraft)
-            return;
-        const turn = lastAssistantTurn(input?.transcript_path);
-        // Same reply as last time we looked: no new prose has landed, so this Stop
-        // is a duplicate or a race with the transcript write. Drop the turn rather
-        // than judge it on a stale message.
-        if (!turn || turn.uuid === s.lastTallyUuid) {
-            writeSession(dir, id, { ...s, turnUsedGraft: false });
-            return;
-        }
-        s.graftTurns = (s.graftTurns ?? 0) + 1;
-        if (hasSavingsTally(turn.text))
-            s.reportedTurns = (s.reportedTurns ?? 0) + 1;
-        s.turnUsedGraft = false;
-        s.lastTallyUuid = turn.uuid;
-        writeSession(dir, id, s);
-    }
-    catch {
-        // A turn-end metric is never worth failing the graph sync over.
-    }
-}
-/**
- * Under trail, a sign in the transcript that the session found something the
- * code won't tell the next person (a check that failed then passed after an
- * edit, a correction, an undone edit, a picked option, a commit; see
- * note-signals.ts) asks the agent to save a learning, by blocking the stop
- * with the reason. Each sign is asked about once, and a session is asked at
- * most NOTE_ASKS_PER_SESSION times; a saved learning starts the signs over.
- * Never blocks twice in a row: Claude Code sets `stop_hook_active` on the
- * stop that follows a block.
- */
-function askForNote(input, dir) {
-    try {
-        if (brand() !== 'trail' || input?.stop_hook_active || !input?.transcript_path || !keepsNotes(dir))
-            return;
-        const id = input?.session_id || 'default';
-        const s = readSession(dir, id);
-        const asked = s.noteAsks ?? [];
-        if (asked.length >= NOTE_ASKS_PER_SESSION)
-            return;
-        const sign = noteSignals(readFileSync(input.transcript_path, 'utf8'), dir).find((x) => !asked.includes(x.key));
-        if (!sign)
-            return;
-        writeSession(dir, id, { ...s, noteAsks: [...asked, sign.key] });
-        process.stdout.write(JSON.stringify({ decision: 'block', reason: noteAsk(sign) }));
-    }
-    catch {
-        // A missed reminder costs one note; a broken Stop hook costs the session.
-    }
-}
-function handleStop(input, dir) {
-    sampleTurnCost(input, dir);
-    countTallyTurn(input, dir);
-    // sync-run.js ships next to this module inside the package, so it resolves in
-    // any repo that installs graft (not just graft's own). Defensive existsSync:
-    // if the package is somehow incomplete, skip rather than wedge on syncing:true.
-    // GRAFT_TEST_SYNC_RUN is a test seam (mirrors GRAFT_TEST_STDIN) so tests can point
-    // this at a stub file inside their own sandbox instead of writing into src/claude/.
-    const syncRun = process.env.GRAFT_TEST_SYNC_RUN ?? claudeScriptPath('sync-run.js');
-    if (!existsSync(syncRun))
-        return;
-    const stats = readStats(dir);
-    if (stats?.dirty && acquireLock(dir)) {
-        patchStats(dir, { syncing: true });
-        const child = spawn(process.execPath, [syncRun, dir], { detached: true, stdio: 'ignore', windowsHide: true });
-        child.unref();
-    }
+    return payloadSessionId({ session_id: input?.conversation_id || input?.session_id });
 }
 const DAY_MS = 24 * 60 * 60 * 1000;
 /**
@@ -587,7 +332,7 @@ export function trackLearningsCommitted(dir) {
     }
 }
 /**
- * Team learnings sitting uncommitted in `.trail/learnings/` (from trail init's
+ * Learnings added to this repo but sitting uncommitted in `.trail/learnings/` (from trail init's
  * read of past sessions, or a session that ended before committing) reach no
  * teammate. Once a day per repo, the first reply says so, with the line that
  * makes the case for committing them. Empty when everything is committed.
@@ -613,8 +358,8 @@ export function uncommittedDirective(dir, now = Date.now()) {
             return `${tag()} trail's shared setup here (.trail/ and .claude/settings.json) isn't committed yet, so teammates' Claude can't read the learnings. Say so once, at the end of your first reply, with this line, word for word: ${line}\n`;
         }
         const line = commitLines({}, teammatesOn(place.checkout), 'repo').uncommitted;
-        const them = n === 1 ? "learning in .trail/learnings/ isn't committed yet, so no teammate's agent has it" : `learnings in .trail/learnings/ aren't committed yet, so no teammate's agent has them`;
-        return `${tag()} ${n} team ${them}. Say so once, at the end of your first reply, with this line, word for word: ${line}\n`;
+        const them = n === 1 ? "learning added to this repo (in .trail/learnings/) isn't committed yet, so no teammate's agent has it" : "learnings added to this repo (in .trail/learnings/) aren't committed yet, so no teammate's agent has them";
+        return `${tag()} ${n} ${them}. Say so once, at the end of your first reply, with this line, word for word: ${line}\n`;
     }
     catch {
         return '';
@@ -668,6 +413,75 @@ function trailAtStart(dir) {
     trackRepoSeen(dir);
     trackLearningsCommitted(dir);
 }
+/**
+ * The learnings part of the session-start text. It needs nothing from
+ * `graft/`: the learnings are their own files. Empty on any read failure,
+ * which costs the session its learnings, never its start.
+ */
+function learningsAtStart(dir) {
+    // 1b (P21, J16): every-repo personal learnings load in every repo, a plain one too, skills on or off; never a
+    // lesson (R47: everyRepoLearnings leaves them out). Shown as standing learnings, phase 0's framing.
+    let every = [];
+    try {
+        every = everyRepoLearnings();
+    }
+    catch { /* none this time */ }
+    try {
+        if (!keepsNotes(dir))
+            return { kept: false, count: 0, extra: standingDirective(every) };
+        const skills = skillsDirective(dir);
+        const standing = brand() === 'trail' ? standingDirective(withEvery(standingLearnings(dir), every)) + uncommittedDirective(dir) : standingDirective(every);
+        return { kept: true, count: noteCounts(dir), extra: skills + standing };
+    }
+    catch {
+        return { kept: false, count: 0, extra: standingDirective(every) };
+    }
+}
+/** This repo's standing learnings, then the every-repo ones not already among them (by id). */
+function withEvery(here, every) {
+    const ids = new Set(here.map((n) => n.id).filter(Boolean));
+    return [...here, ...every.filter((n) => !n.id || !ids.has(n.id))];
+}
+/**
+ * D87: what the person kept on `trail init`'s screen, named once at the next interactive startup or resume in that
+ * repo with its undo. Skills on or off. A notice where the host shows one, else context from Trail.
+ */
+function keptAtStart(input, dir) {
+    try {
+        const source = typeof input?.source === 'string' && input.source ? input.source : 'startup';
+        if (source !== 'startup' && source !== 'resume')
+            return {};
+        if (typeof input?.agent_id === 'string' && input.agent_id)
+            return {};
+        if (String(process.env.CLAUDE_CODE_ENTRYPOINT ?? '').startsWith('sdk'))
+            return {};
+        const cwd = typeof input?.cwd === 'string' && input.cwd ? input.cwd : dir;
+        const line = keptNotice(repoPlace(cwd).key, process.env, trailNow(process.env));
+        if (!line)
+            return {};
+        return hostFacts(process.env, detectHost(input).host).startNotice ? { notice: line } : { context: keptContext(line) };
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * The session-start text: the orientation from `graft/INDEX.md` with the
+ * learnings in it, or, where INDEX.md is missing (never built here; `graft/` is
+ * git-ignored, so a teammate's fresh clone has none), the learnings alone.
+ */
+function orientationAtStart(dir, learnings) {
+    try {
+        const idx = readFileSync(join(resolveContextDir(dir), 'INDEX.md'), 'utf8');
+        const banner = staleBanner(indexFreshness(dir)) ?? undefined;
+        // Where the map is: `.trail/cache/` in a repo on trail, `graft/` elsewhere (context/map-dir.ts).
+        const mapDir = relative(dir, resolveContextDir(dir)).split('\\').join('/') || 'graft';
+        return formatOrientation(idx, undefined, banner, learnings.count, learnings.kept, learnings.extra, mapDir);
+    }
+    catch {
+        return learnings.kept ? `${tag()} ${teamNotesDirective(learnings.count, true)}${learnings.extra}` : learnings.extra;
+    }
+}
 /** The repo's committed `.mcp.json` still registers trail's server (set up before 0.23). */
 function repoNamesTrailServer(dir) {
     try {
@@ -678,16 +492,36 @@ function repoNamesTrailServer(dir) {
     }
 }
 export async function main(event) {
+    // Shims before pre-bash.js existed send PreToolUse here: hand it straight
+    // over, before any of the work the other events share.
+    if (event === 'pre-bash') {
+        await preBashMain(event);
+        return;
+    }
     // trail's own headless Claude calls (the first-run read of past sessions) run with this set.
     if (process.env.TRAIL_NO_HOOKS === '1')
         return;
+    const input = readStdin();
     // Registered in the repo and in ~/.claude, Claude Code runs both: one answers.
-    if (globalCopyCovers(event, process.argv[1]))
+    // Who sent the payload decides first: Copilot CLI runs only the repo's copy.
+    if (globalCopyCovers(event, process.argv[1], homedir(), process.env, input))
         return;
-    const input = readStdin();
     const dir = projectDir(input);
+    // A failed Bash call (PostToolUseFailure, D34): the skills mark, and 1b's wall fix as its one answer, before any of
+    // the work the other events share.
+    if (event === 'post-bash-fail') {
+        emitHook('PostToolUseFailure', await postBashPart(input, dir, true));
+        return;
+    }
+    // Codex's PostToolUse on Bash, on every exit (3.4): the skills mark, and the wall fix where its context reaches the model.
+    if (event === 'codex-post-bash') {
+        emitHook('PostToolUse', await codexPostBashPart(input, dir));
+        return;
+    }
     adoptRepoBrand(dir, process.env, hostsWiredForTrail);
     if (event === 'session-start') {
+        // The skills part first, so nothing below can skip it (a repo with no graft/INDEX.md included).
+        const skills = await sessionStartPart(input, dir);
         // Before anything is emitted: refresh this repo's wiring if it was written by
         // an older graft, and pick up any cached "newer version on npm" answer.
         // background:false — the registry check stays off the network here; the CLI
@@ -703,27 +537,22 @@ export async function main(event) {
         // terminal never fires it) goes now. Once a day at most, never waited on.
         flushClosedSessions(dir);
         maybeFlushInBackground();
+        // Once per repo: older versions kept the prompt in each session file.
+        try {
+            dropStoredPrompts(dir);
+        }
+        catch { /* tried again next session */ }
         trailAtStart(dir);
         // A repo on trail, opened on a machine that has graft but not the trail command.
         // Only while its .mcp.json still names a trail server: once it doesn't, trail: true takes back the stand-in.
         if (repoWiredForTrail(dir))
             fitTrailServerToMachine(homedir(), resolve(dir), { trail: trailOnPath() || !repoNamesTrailServer(dir), graft: commandOnPath('graft') });
-        try {
-            const idx = readFileSync(join(resolveContextDir(dir), 'INDEX.md'), 'utf8');
-            const banner = staleBanner(indexFreshness(dir)) ?? undefined;
-            const kept = keepsNotes(dir);
-            const skills = kept ? skillsDirective(dir, cmd('graft skills show')) : '';
-            const underTrail = kept && brand() === 'trail';
-            const standing = underTrail ? standingDirective(standingLearnings(dir)) + uncommittedDirective(dir) : '';
-            const mapDir = relative(dir, resolveContextDir(dir)).split('\\').join('/') || 'graft';
-            const orientation = formatOrientation(idx, undefined, banner, noteCount(dir), kept, skills + standing, mapDir);
-            emit('SessionStart', upkeep.length ? `${upkeep.join('\n')}\n\n${orientation}` : orientation);
-        }
-        catch {
-            // No INDEX.md (never built here). An upgrade nudge is still worth saying.
-            if (upkeep.length)
-                emit('SessionStart', upkeep.join('\n'));
-        }
+        const text = orientationAtStart(dir, learningsAtStart(dir));
+        const kept = keptAtStart(input, dir);
+        // The skills context comes after the learnings; its notice is for the person.
+        const out = [upkeep.join('\n'), text, skills.context, kept.context].filter(Boolean).join('\n\n');
+        const notice = [skills.notice, kept.notice].filter(Boolean).join('\n') || undefined;
+        emitHook('SessionStart', { context: out, notice });
         return;
     }
     // Claude closing: send the queue from a detached child, so quitting isn't slowed.
@@ -737,6 +566,10 @@ export async function main(event) {
     }
     if (event === 'tool-savings') {
         handleToolUse(input, dir);
+        recordSkillUse(skillOfToolUse(input), input, dir);
+        // PostToolUse on Bash: the skills mark, and the post-tool offer channel's context (3.4),
+        // then the learnings about the file the call touched, in the same one answer.
+        emitHook('PostToolUse', withTouchLearnings(await postBashPart(input, dir, false), input, dir));
         return;
     }
     if (event === 'cursor-post-tool') {
@@ -756,47 +589,18 @@ export async function main(event) {
         return;
     }
     if (event === 'stop') {
-        handleStop(input, dir);
-        askForNote(input, dir);
+        await handleStopEvent(input, dir);
         return;
     }
+    // An edit's payload, not a Stop's: the turn-end bookkeeping only, so its one answer stays the edit's.
     if (event === 'post-edit-sync') {
         await handlePostEdit(input, dir);
-        handleStop(input, dir);
+        await handleStopEvent(input, dir, { skills: false });
         return;
     }
     if (event === 'prompt') {
-        const prompt = String(input?.prompt ?? '').trim();
-        // Background completion notices are machine events, not user queries.
-        if (prompt.length < MIN_PROMPT_CHARS || prompt.startsWith('<task-notification>'))
-            return;
-        // Pointers-only, small, gated. No --source: per-prompt injected tokens are
-        // fresh full-price input on every turn (unlike the cached SessionStart
-        // orientation), so the pack carries locators, never inlined code — the agent
-        // pulls spans itself via `graft ask --source` when a pointer looks right.
-        // relevantRetrieval then drops the pack entirely when the prompt barely
-        // overlaps the top hit or when every hit was already injected this session.
-        const askArgs = withContextDirArg(dir, ['ask', prompt, '.', '--json', '-n', '3']);
-        // "You're working in backend/, weight it": only fires on a multi-scope
-        // repo whose lastFile resolves cleanly to one scope — see lastFileScopeHint.
-        const scopeHint = lastFileScopeHint(dir, readStats(dir)?.lastFile);
-        if (scopeHint)
-            askArgs.push('--in', scopeHint);
-        const ask = graftJson(dir, askArgs, promptAskTimeout(dir));
-        if (!ask)
-            return;
-        const id = input.session_id || 'default';
-        const s = readSession(dir, id);
-        s.lastQuery = prompt;
-        const agent = input?.agent?.name;
-        if (agent)
-            s.perAgentQuery[agent] = prompt;
-        // Learnings first: what an earlier session worked out matters more than where code is.
-        const notes = brand() === 'trail' ? notesForPrompt(ask, s) : null;
-        const txt = [notes, relevantRetrieval(ask, s)].filter(Boolean).join('\n\n');
-        if (txt)
-            emit('UserPromptSubmit', txt);
-        writeSession(dir, id, s);
+        await handlePrompt(input, dir);
+        return;
     }
 }
 //# sourceMappingURL=hooks.js.map