@basou/core 0.48.1 → 0.50.0

package/dist/index.js

@@ -1,10 +1,10 @@
 // src/adapters/command-lookup.ts
 import { spawn } from "child_process";
 async function isOnPath(command) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const child = spawn("which", [command], { stdio: "ignore" });
-    child.on("error", () => resolve4(false));
-    child.on("exit", (code) => resolve4(code === 0));
+    child.on("error", () => resolve5(false));
+    child.on("exit", (code) => resolve5(code === 0));
   });
 }
 
@@ -23,13 +23,142 @@ function summarizeAdapterOutput(_stream, _raw) {
   throw new Error("adapter_output summary is not implemented in this release");
 }
 
+// src/adapters/codex/hooks-json.ts
+var SESSION_START_HOOK_TIMEOUT_SECONDS = 30;
+var SESSION_START_HOOK_MATCHER = "startup|resume|clear";
+var SESSION_START_HOOK_CONTEXT_LIMIT = 0;
+var SESSION_START_HOOK_STATUS_MESSAGE = "basou orient";
+var BASOU_SESSION_START_HOOK = /(?:\bbasou|(?:@basou|packages)\/cli\/dist\/index\.js['"]?)\s+hook\s+session-start\b/;
+function isBasouSessionStartHookCommand(command) {
+  return BASOU_SESSION_START_HOOK.test(command);
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function buildSessionStartHookCommand(options) {
+  return `node ${shellQuote(options.cliEntry)} hook session-start 2>/dev/null || true`;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function cloneHooksFile(hooksFile) {
+  if (hooksFile === void 0 || hooksFile === null) return {};
+  if (!isRecord(hooksFile)) {
+    throw new Error("The Codex hooks.json is not a JSON object.");
+  }
+  return structuredClone(hooksFile);
+}
+function canonicalHandler(command) {
+  return {
+    type: "command",
+    command,
+    timeout: SESSION_START_HOOK_TIMEOUT_SECONDS,
+    statusMessage: SESSION_START_HOOK_STATUS_MESSAGE,
+    additionalContextLimit: SESSION_START_HOOK_CONTEXT_LIMIT
+  };
+}
+function handlerIsCanonical(entry, command) {
+  const want = canonicalHandler(command);
+  return Object.keys(want).every((k) => entry[k] === want[k]);
+}
+function upsertSessionStartHook(hooksFile, command) {
+  const root = cloneHooksFile(hooksFile);
+  if (root.hooks === void 0) {
+    root.hooks = {};
+  } else if (!isRecord(root.hooks)) {
+    throw new Error("The 'hooks' key in the Codex hooks.json is not an object.");
+  }
+  const hooks = root.hooks;
+  if (hooks.SessionStart === void 0) {
+    hooks.SessionStart = [];
+  } else if (!Array.isArray(hooks.SessionStart)) {
+    throw new Error("The 'hooks.SessionStart' key in the Codex hooks.json is not an array.");
+  }
+  const groups = hooks.SessionStart;
+  for (const group of groups) {
+    if (!isRecord(group) || !Array.isArray(group.hooks)) continue;
+    for (const entry of group.hooks) {
+      if (!isRecord(entry)) continue;
+      if (typeof entry.command === "string" && isBasouSessionStartHookCommand(entry.command)) {
+        const unchanged = handlerIsCanonical(entry, command);
+        Object.assign(entry, canonicalHandler(command));
+        return { hooksFile: root, action: unchanged ? "unchanged" : "updated" };
+      }
+    }
+  }
+  groups.push({ matcher: SESSION_START_HOOK_MATCHER, hooks: [canonicalHandler(command)] });
+  return { hooksFile: root, action: "installed" };
+}
+function removeSessionStartHook(hooksFile) {
+  const root = cloneHooksFile(hooksFile);
+  if (!isRecord(root.hooks) || !Array.isArray(root.hooks.SessionStart)) {
+    return { hooksFile: root, action: "absent" };
+  }
+  const hooks = root.hooks;
+  const groups = hooks.SessionStart;
+  let removed = false;
+  const kept = [];
+  for (const group of groups) {
+    if (!isRecord(group) || !Array.isArray(group.hooks)) {
+      kept.push(group);
+      continue;
+    }
+    const keptHandlers = group.hooks.filter((entry) => {
+      if (isRecord(entry) && typeof entry.command === "string" && isBasouSessionStartHookCommand(entry.command)) {
+        removed = true;
+        return false;
+      }
+      return true;
+    });
+    if (keptHandlers.length === group.hooks.length) {
+      kept.push(group);
+    } else if (keptHandlers.length > 0) {
+      group.hooks = keptHandlers;
+      kept.push(group);
+    }
+  }
+  if (!removed) return { hooksFile: root, action: "absent" };
+  if (kept.length === 0) {
+    delete hooks.SessionStart;
+  } else {
+    hooks.SessionStart = kept;
+  }
+  if (Object.keys(hooks).length === 0) {
+    delete root.hooks;
+  }
+  return { hooksFile: root, action: "removed" };
+}
+function findBasouSessionStartHook(hooksFile) {
+  if (!isRecord(hooksFile) || !isRecord(hooksFile.hooks) || !Array.isArray(hooksFile.hooks.SessionStart)) {
+    return null;
+  }
+  const groups = hooksFile.hooks.SessionStart;
+  for (let g = 0; g < groups.length; g++) {
+    const group = groups[g];
+    if (!isRecord(group) || !Array.isArray(group.hooks)) continue;
+    for (let h = 0; h < group.hooks.length; h++) {
+      const entry = group.hooks[h];
+      if (isRecord(entry) && typeof entry.command === "string" && isBasouSessionStartHookCommand(entry.command)) {
+        return {
+          command: entry.command,
+          groupIndex: g,
+          handlerIndex: h,
+          matcher: typeof group.matcher === "string" ? group.matcher : void 0,
+          handler: structuredClone(entry)
+        };
+      }
+    }
+  }
+  return null;
+}
+
 // src/adapters/claude-code/settings-hook.ts
 var STOP_HOOK_TIMEOUT_SECONDS = 20;
 var BASOU_STOP_HOOK = /(?:\bbasou|(?:@basou|packages)\/cli\/dist\/index\.js['"]?)\s+hook\s+stop\b/;
 function isBasouStopHookCommand(command) {
   return BASOU_STOP_HOOK.test(command);
 }
-function shellQuote(value) {
+function shellQuote2(value) {
   return `'${value.replace(/'/g, "'\\''")}'`;
 }
 function buildStopHookCommand(options) {
@@ -38,14 +167,14 @@ function buildStopHookCommand(options) {
   if (options.requireReview === true) flags.push("--require-review");
   if (options.minEdits !== void 0) flags.push(`--min-edits ${options.minEdits}`);
   const suffix = flags.length > 0 ? ` ${flags.join(" ")}` : "";
-  return `node ${shellQuote(options.cliEntry)} hook stop${suffix} 2>/dev/null || true`;
+  return `node ${shellQuote2(options.cliEntry)} hook stop${suffix} 2>/dev/null || true`;
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function cloneSettings(settings) {
   if (settings === void 0 || settings === null) return {};
-  if (!isRecord(settings)) {
+  if (!isRecord2(settings)) {
     throw new Error("Claude settings is not a JSON object.");
   }
   return structuredClone(settings);
@@ -54,7 +183,7 @@ function upsertStopHook(settings, command) {
   const root = cloneSettings(settings);
   if (root.hooks === void 0) {
     root.hooks = {};
-  } else if (!isRecord(root.hooks)) {
+  } else if (!isRecord2(root.hooks)) {
     throw new Error("The 'hooks' key in Claude settings is not an object.");
   }
   const hooks = root.hooks;
@@ -65,9 +194,9 @@ function upsertStopHook(settings, command) {
   }
   const stop = hooks.Stop;
   for (const group of stop) {
-    if (!isRecord(group) || !Array.isArray(group.hooks)) continue;
+    if (!isRecord2(group) || !Array.isArray(group.hooks)) continue;
     for (const entry of group.hooks) {
-      if (!isRecord(entry)) continue;
+      if (!isRecord2(entry)) continue;
       if (typeof entry.command === "string" && isBasouStopHookCommand(entry.command)) {
         const unchanged = entry.type === "command" && entry.command === command && entry.timeout === STOP_HOOK_TIMEOUT_SECONDS;
         entry.type = "command";
@@ -82,7 +211,7 @@ function upsertStopHook(settings, command) {
 }
 function removeStopHook(settings) {
   const root = cloneSettings(settings);
-  if (!isRecord(root.hooks) || !Array.isArray(root.hooks.Stop)) {
+  if (!isRecord2(root.hooks) || !Array.isArray(root.hooks.Stop)) {
     return { settings: root, action: "absent" };
   }
   const hooks = root.hooks;
@@ -90,12 +219,12 @@ function removeStopHook(settings) {
   let removed = false;
   const newStop = [];
   for (const group of stop) {
-    if (!isRecord(group) || !Array.isArray(group.hooks)) {
+    if (!isRecord2(group) || !Array.isArray(group.hooks)) {
       newStop.push(group);
       continue;
     }
     const keptHooks = group.hooks.filter((entry) => {
-      if (isRecord(entry) && typeof entry.command === "string" && isBasouStopHookCommand(entry.command)) {
+      if (isRecord2(entry) && typeof entry.command === "string" && isBasouStopHookCommand(entry.command)) {
         removed = true;
         return false;
       }
@@ -122,19 +251,198 @@ function removeStopHook(settings) {
   return { settings: root, action: "removed" };
 }
 function findBasouStopHookCommand(settings) {
-  if (!isRecord(settings) || !isRecord(settings.hooks) || !Array.isArray(settings.hooks.Stop)) {
+  if (!isRecord2(settings) || !isRecord2(settings.hooks) || !Array.isArray(settings.hooks.Stop)) {
     return null;
   }
   for (const group of settings.hooks.Stop) {
-    if (!isRecord(group) || !Array.isArray(group.hooks)) continue;
+    if (!isRecord2(group) || !Array.isArray(group.hooks)) continue;
     for (const entry of group.hooks) {
-      if (isRecord(entry) && typeof entry.command === "string" && isBasouStopHookCommand(entry.command)) {
+      if (isRecord2(entry) && typeof entry.command === "string" && isBasouStopHookCommand(entry.command)) {
         return entry.command;
       }
     }
   }
   return null;
 }
+var ENTRY = String.raw`(?:[^\s'"]*/)?(?:@basou|packages)/cli/dist/index\.js`;
+var INVOCATION = String.raw`(?:basou|node[ \t]+(?:'(?:[^']*/)?(?:@basou|packages)/cli/dist/index\.js'|"(?:[^"]*/)?(?:@basou|packages)/cli/dist/index\.js"|${ENTRY}))`;
+var WRAPPER = String.raw`(?:[ \t]+2>[ \t]*/dev/null)?(?:[ \t]*\|\|[ \t]*true)?`;
+var CLAUDE_SESSION_START = new RegExp(
+  String.raw`^[ \t]*${INVOCATION}[ \t]+hook[ \t]+session-start${WRAPPER}[ \t]*$`
+);
+var CLAUDE_ORIENT_SESSION_START = new RegExp(
+  String.raw`^[ \t]*${INVOCATION}[ \t]+orient${WRAPPER}[ \t]*$`
+);
+function isClaudeSessionStartHookCommand(command) {
+  return CLAUDE_SESSION_START.test(command);
+}
+function isBasouOrientSessionStartCommand(command) {
+  return CLAUDE_ORIENT_SESSION_START.test(command);
+}
+function basouSessionStartKind(entry) {
+  if (!isRecord2(entry) || typeof entry.command !== "string") return null;
+  if (isClaudeSessionStartHookCommand(entry.command)) return "session-start";
+  if (isBasouOrientSessionStartCommand(entry.command)) return "orient";
+  return null;
+}
+function matcherKey(group) {
+  const m = group.matcher;
+  return m === void 0 || m === "" || m === "*" ? "*" : String(m);
+}
+function upsertClaudeSessionStartHook(settings, command) {
+  const root = cloneSettings(settings);
+  if (root.hooks === void 0) {
+    root.hooks = {};
+  } else if (!isRecord2(root.hooks)) {
+    throw new Error("The 'hooks' key in Claude settings is not an object.");
+  }
+  const hooks = root.hooks;
+  if (hooks.SessionStart === void 0) {
+    hooks.SessionStart = [];
+  } else if (!Array.isArray(hooks.SessionStart)) {
+    throw new Error("The 'hooks.SessionStart' key in Claude settings is not an array.");
+  }
+  const groups = hooks.SessionStart;
+  let found = false;
+  let changed = false;
+  let replacedOrient = false;
+  const keptUnder = /* @__PURE__ */ new Set();
+  const nextGroups = [];
+  for (const group of groups) {
+    if (!isRecord2(group) || !Array.isArray(group.hooks)) {
+      nextGroups.push(group);
+      continue;
+    }
+    const key = matcherKey(group);
+    const nextHooks = [];
+    let removedHere = false;
+    for (const entry of group.hooks) {
+      const kind = basouSessionStartKind(entry);
+      if (kind === null || !isRecord2(entry)) {
+        nextHooks.push(entry);
+        continue;
+      }
+      found = true;
+      if (kind === "orient") replacedOrient = true;
+      if (keptUnder.has(key)) {
+        changed = true;
+        removedHere = true;
+        continue;
+      }
+      if (entry.type !== "command" || entry.command !== command || entry.timeout !== SESSION_START_HOOK_TIMEOUT_SECONDS) {
+        changed = true;
+      }
+      entry.type = "command";
+      entry.command = command;
+      entry.timeout = SESSION_START_HOOK_TIMEOUT_SECONDS;
+      keptUnder.add(key);
+      nextHooks.push(entry);
+    }
+    if (removedHere && nextHooks.length === 0) continue;
+    group.hooks = nextHooks;
+    nextGroups.push(group);
+  }
+  hooks.SessionStart = nextGroups;
+  if (!found) {
+    nextGroups.push({
+      matcher: SESSION_START_HOOK_MATCHER,
+      hooks: [{ type: "command", command, timeout: SESSION_START_HOOK_TIMEOUT_SECONDS }]
+    });
+    return { settings: root, action: "installed" };
+  }
+  if (replacedOrient) return { settings: root, action: "replaced" };
+  return { settings: root, action: changed ? "updated" : "unchanged" };
+}
+function removeClaudeSessionStartHook(settings) {
+  const root = cloneSettings(settings);
+  if (!isRecord2(root.hooks) || !Array.isArray(root.hooks.SessionStart)) {
+    return { settings: root, action: "absent" };
+  }
+  const hooks = root.hooks;
+  let removed = false;
+  const nextGroups = [];
+  for (const group of hooks.SessionStart) {
+    if (!isRecord2(group) || !Array.isArray(group.hooks)) {
+      nextGroups.push(group);
+      continue;
+    }
+    const keptHooks = group.hooks.filter((entry) => basouSessionStartKind(entry) === null);
+    if (keptHooks.length === group.hooks.length) {
+      nextGroups.push(group);
+    } else {
+      removed = true;
+      if (keptHooks.length > 0) {
+        group.hooks = keptHooks;
+        nextGroups.push(group);
+      }
+    }
+  }
+  if (!removed) return { settings: root, action: "absent" };
+  if (nextGroups.length === 0) {
+    delete hooks.SessionStart;
+  } else {
+    hooks.SessionStart = nextGroups;
+  }
+  if (Object.keys(hooks).length === 0) delete root.hooks;
+  return { settings: root, action: "removed" };
+}
+function findClaudeSessionStartHooks(settings) {
+  const found = [];
+  if (!isRecord2(settings) || !isRecord2(settings.hooks)) return found;
+  const groups = settings.hooks.SessionStart;
+  if (!Array.isArray(groups)) return found;
+  for (const group of groups) {
+    if (!isRecord2(group) || !Array.isArray(group.hooks)) continue;
+    for (const entry of group.hooks) {
+      const kind = basouSessionStartKind(entry);
+      if (kind === null || !isRecord2(entry) || typeof entry.command !== "string") continue;
+      found.push({
+        command: entry.command,
+        kind,
+        matcher: typeof group.matcher === "string" ? group.matcher : void 0
+      });
+    }
+  }
+  return found;
+}
+function isClaudeSessionStartMalformed(settings) {
+  return isRecord2(settings) && isRecord2(settings.hooks) && settings.hooks.SessionStart !== void 0 && !Array.isArray(settings.hooks.SessionStart);
+}
+var RUNS_BASOU = new RegExp(
+  String.raw`(?:^|[\s;&|(])(?:basou|node(?:[ \t]+-[^\s]+)*[ \t]+(?:'[^']*(?:@basou|packages)/cli/dist/index\.js'|"[^"]*(?:@basou|packages)/cli/dist/index\.js"|${ENTRY})|npx(?:[ \t]+-y)?[ \t]+@basou/cli)[ \t]+(orient|hook[ \t]+session-start)(?=$|[\s;&|)])`,
+  "g"
+);
+function isInsideQuotes(text, index) {
+  let single = false;
+  let double = false;
+  for (let i = 0; i < index; i++) {
+    const c = text[i];
+    if (c === "'" && !double) single = !single;
+    else if (c === '"' && !single) double = !double;
+  }
+  return single || double;
+}
+function findUnrecognizedSessionStart(settings) {
+  const found = [];
+  if (!isRecord2(settings) || !isRecord2(settings.hooks)) return found;
+  const groups = settings.hooks.SessionStart;
+  if (!Array.isArray(groups)) return found;
+  for (const group of groups) {
+    if (!isRecord2(group) || !Array.isArray(group.hooks)) continue;
+    for (const entry of group.hooks) {
+      if (!isRecord2(entry) || typeof entry.command !== "string") continue;
+      if (basouSessionStartKind(entry) !== null) continue;
+      const command = entry.command;
+      for (const m of command.matchAll(RUNS_BASOU)) {
+        const at = (m.index ?? 0) + (m[0].length - m[0].trimStart().length);
+        if (isInsideQuotes(command, at)) continue;
+        found.push({ command, runs: m[1] === "orient" ? "orient" : "session-start" });
+        break;
+      }
+    }
+  }
+  return found;
+}
 
 // src/adapters/claude-code/ask-user-question.ts
 function readString(value) {
@@ -913,6 +1221,9 @@ function claudeTranscriptToImportPayload(records, options) {
   }
   if (minTs === void 0 || maxTs === void 0) return null;
   if (derived.length === 0) return null;
+  for (const observed of options.observedFiles ?? []) {
+    relatedFiles.add(observed.path);
+  }
   derived.sort((a, b) => Date.parse(a.occurred_at) - Date.parse(b.occurred_at));
   const events = [
     sessionStartedEvent(minTs, placeholderSessionId),
@@ -1062,135 +1373,6 @@ async function resolveCodexCommand(lookup = isOnPath) {
   throw new Error("Codex CLI not found in PATH. Install codex first.");
 }
 
-// src/adapters/codex/hooks-json.ts
-var SESSION_START_HOOK_TIMEOUT_SECONDS = 30;
-var SESSION_START_HOOK_MATCHER = "startup|resume|clear";
-var SESSION_START_HOOK_CONTEXT_LIMIT = 0;
-var SESSION_START_HOOK_STATUS_MESSAGE = "basou orient";
-var BASOU_SESSION_START_HOOK = /(?:\bbasou|(?:@basou|packages)\/cli\/dist\/index\.js['"]?)\s+hook\s+session-start\b/;
-function isBasouSessionStartHookCommand(command) {
-  return BASOU_SESSION_START_HOOK.test(command);
-}
-function shellQuote2(value) {
-  return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function buildSessionStartHookCommand(options) {
-  return `node ${shellQuote2(options.cliEntry)} hook session-start 2>/dev/null || true`;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function cloneHooksFile(hooksFile) {
-  if (hooksFile === void 0 || hooksFile === null) return {};
-  if (!isRecord2(hooksFile)) {
-    throw new Error("The Codex hooks.json is not a JSON object.");
-  }
-  return structuredClone(hooksFile);
-}
-function canonicalHandler(command) {
-  return {
-    type: "command",
-    command,
-    timeout: SESSION_START_HOOK_TIMEOUT_SECONDS,
-    statusMessage: SESSION_START_HOOK_STATUS_MESSAGE,
-    additionalContextLimit: SESSION_START_HOOK_CONTEXT_LIMIT
-  };
-}
-function handlerIsCanonical(entry, command) {
-  const want = canonicalHandler(command);
-  return Object.keys(want).every((k) => entry[k] === want[k]);
-}
-function upsertSessionStartHook(hooksFile, command) {
-  const root = cloneHooksFile(hooksFile);
-  if (root.hooks === void 0) {
-    root.hooks = {};
-  } else if (!isRecord2(root.hooks)) {
-    throw new Error("The 'hooks' key in the Codex hooks.json is not an object.");
-  }
-  const hooks = root.hooks;
-  if (hooks.SessionStart === void 0) {
-    hooks.SessionStart = [];
-  } else if (!Array.isArray(hooks.SessionStart)) {
-    throw new Error("The 'hooks.SessionStart' key in the Codex hooks.json is not an array.");
-  }
-  const groups = hooks.SessionStart;
-  for (const group of groups) {
-    if (!isRecord2(group) || !Array.isArray(group.hooks)) continue;
-    for (const entry of group.hooks) {
-      if (!isRecord2(entry)) continue;
-      if (typeof entry.command === "string" && isBasouSessionStartHookCommand(entry.command)) {
-        const unchanged = handlerIsCanonical(entry, command);
-        Object.assign(entry, canonicalHandler(command));
-        return { hooksFile: root, action: unchanged ? "unchanged" : "updated" };
-      }
-    }
-  }
-  groups.push({ matcher: SESSION_START_HOOK_MATCHER, hooks: [canonicalHandler(command)] });
-  return { hooksFile: root, action: "installed" };
-}
-function removeSessionStartHook(hooksFile) {
-  const root = cloneHooksFile(hooksFile);
-  if (!isRecord2(root.hooks) || !Array.isArray(root.hooks.SessionStart)) {
-    return { hooksFile: root, action: "absent" };
-  }
-  const hooks = root.hooks;
-  const groups = hooks.SessionStart;
-  let removed = false;
-  const kept = [];
-  for (const group of groups) {
-    if (!isRecord2(group) || !Array.isArray(group.hooks)) {
-      kept.push(group);
-      continue;
-    }
-    const keptHandlers = group.hooks.filter((entry) => {
-      if (isRecord2(entry) && typeof entry.command === "string" && isBasouSessionStartHookCommand(entry.command)) {
-        removed = true;
-        return false;
-      }
-      return true;
-    });
-    if (keptHandlers.length === group.hooks.length) {
-      kept.push(group);
-    } else if (keptHandlers.length > 0) {
-      group.hooks = keptHandlers;
-      kept.push(group);
-    }
-  }
-  if (!removed) return { hooksFile: root, action: "absent" };
-  if (kept.length === 0) {
-    delete hooks.SessionStart;
-  } else {
-    hooks.SessionStart = kept;
-  }
-  if (Object.keys(hooks).length === 0) {
-    delete root.hooks;
-  }
-  return { hooksFile: root, action: "removed" };
-}
-function findBasouSessionStartHook(hooksFile) {
-  if (!isRecord2(hooksFile) || !isRecord2(hooksFile.hooks) || !Array.isArray(hooksFile.hooks.SessionStart)) {
-    return null;
-  }
-  const groups = hooksFile.hooks.SessionStart;
-  for (let g = 0; g < groups.length; g++) {
-    const group = groups[g];
-    if (!isRecord2(group) || !Array.isArray(group.hooks)) continue;
-    for (let h = 0; h < group.hooks.length; h++) {
-      const entry = group.hooks[h];
-      if (isRecord2(entry) && typeof entry.command === "string" && isBasouSessionStartHookCommand(entry.command)) {
-        return {
-          command: entry.command,
-          groupIndex: g,
-          handlerIndex: h,
-          matcher: typeof group.matcher === "string" ? group.matcher : void 0,
-          handler: structuredClone(entry)
-        };
-      }
-    }
-  }
-  return null;
-}
-
 // src/schemas/observed-duration.ts
 function readObservedDuration(ev) {
   const stored = ev.duration_ms;
@@ -5619,20 +5801,41 @@ async function getDiff(repoRoot, baseRef, headRef) {
   let raw;
   try {
     raw = await git.raw(["diff", "--name-status", `${baseRef}..${headRef}`]);
+  } catch (error) {
+    throw translateDiffError(error);
+  }
+  return { changed_files: parseDiffNameStatus(raw) };
+}
+async function getChangesSince(repoRoot, baseRef) {
+  let git;
+  try {
+    git = safeSimpleGit(repoRoot);
   } catch (error) {
     if (isGitNotFound(error)) {
       throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
     }
-    const message = error instanceof Error ? error.message : "";
-    if (/not a git repository/i.test(message)) {
-      throw new Error("Not a git repository", { cause: error });
-    }
-    if (message.includes("bad revision") || message.includes("unknown revision") || message.includes("ambiguous argument")) {
-      throw new Error("Invalid ref", { cause: error });
-    }
-    throw new Error("Failed to compute git diff", { cause: error });
+    throw new Error("Not a git repository", { cause: error });
   }
-  return { changed_files: parseDiffNameStatus(raw) };
+  let raw;
+  try {
+    raw = await git.raw(["-c", "core.quotePath=false", "diff", "--name-status", baseRef]);
+  } catch (error) {
+    throw translateDiffError(error);
+  }
+  return parseDiffNameStatus(raw);
+}
+function translateDiffError(error) {
+  if (isGitNotFound(error)) {
+    return new Error("Git executable not found in PATH. Install git first.", { cause: error });
+  }
+  const message = error instanceof Error ? error.message : "";
+  if (/not a git repository/i.test(message)) {
+    return new Error("Not a git repository", { cause: error });
+  }
+  if (message.includes("bad revision") || message.includes("unknown revision") || message.includes("ambiguous argument") || message.includes("bad object") || message.includes("Invalid revision range")) {
+    return new Error("Invalid ref", { cause: error });
+  }
+  return new Error("Failed to compute git diff", { cause: error });
 }
 function parseDiffNameStatus(raw) {
   const lines = raw.split("\n").filter((l) => l.trim() !== "");
@@ -5661,6 +5864,135 @@ function parseDiffNameStatus(raw) {
   return changes;
 }
 
+// src/git/working-tree.ts
+async function getWorkingTreeChanges(repoRoot) {
+  let git;
+  try {
+    git = safeSimpleGit(repoRoot);
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    throw new Error("Not a git repository", { cause: error });
+  }
+  let status;
+  try {
+    status = await git.status();
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    const message = error instanceof Error ? error.message : "";
+    if (/not a git repository/i.test(message)) {
+      throw new Error("Not a git repository", { cause: error });
+    }
+    throw new Error("Failed to read git status", { cause: error });
+  }
+  const byPath = /* @__PURE__ */ new Map();
+  const put = (change) => {
+    if (!byPath.has(change.path)) byPath.set(change.path, change);
+  };
+  const conflicted = new Set(status.conflicted);
+  for (const entry of status.renamed) {
+    if (conflicted.has(entry.to)) continue;
+    put({ path: entry.to, status: "renamed", old_path: entry.from });
+  }
+  for (const path2 of status.deleted) {
+    if (conflicted.has(path2)) continue;
+    put({ path: path2, status: "deleted" });
+  }
+  for (const path2 of [...status.created, ...status.not_added]) {
+    if (conflicted.has(path2)) continue;
+    put({ path: path2, status: "added" });
+  }
+  for (const path2 of status.modified) {
+    if (conflicted.has(path2)) continue;
+    put({ path: path2, status: "modified" });
+  }
+  return [...byPath.values()].sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+async function readHeadSha(repoRoot) {
+  let git;
+  try {
+    git = safeSimpleGit(repoRoot);
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    throw new Error("Not a git repository", { cause: error });
+  }
+  let inside;
+  try {
+    inside = await git.checkIsRepo();
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    throw new Error("Failed to read git status", { cause: error });
+  }
+  if (!inside) throw new Error("Not a git repository");
+  try {
+    const head = (await git.revparse(["HEAD"])).trimEnd();
+    return head.length > 0 ? head : null;
+  } catch {
+    return null;
+  }
+}
+async function getUntrackedFiles(repoRoot) {
+  let git;
+  try {
+    git = safeSimpleGit(repoRoot);
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    throw new Error("Not a git repository", { cause: error });
+  }
+  let raw;
+  try {
+    raw = await git.raw([
+      "-c",
+      "core.quotePath=false",
+      "ls-files",
+      "--others",
+      "--exclude-standard",
+      "-z"
+    ]);
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    const message = error instanceof Error ? error.message : "";
+    if (/not a git repository/i.test(message)) {
+      throw new Error("Not a git repository", { cause: error });
+    }
+    throw new Error("Failed to read git status", { cause: error });
+  }
+  const changes = [];
+  for (const path2 of raw.split("\0")) {
+    if (path2.length === 0) continue;
+    if (path2.endsWith("/")) continue;
+    changes.push({ path: path2, status: "added" });
+  }
+  return changes.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+async function readEmptyTreeSha(repoRoot) {
+  let git;
+  try {
+    git = safeSimpleGit(repoRoot);
+  } catch (error) {
+    if (isGitNotFound(error)) {
+      throw new Error("Git executable not found in PATH. Install git first.", { cause: error });
+    }
+    throw new Error("Not a git repository", { cause: error });
+  }
+  try {
+    return (await git.raw(["hash-object", "-t", "tree", "/dev/null"])).trimEnd();
+  } catch (error) {
+    throw new Error("Failed to read git status", { cause: error });
+  }
+}
+
 // src/handoff/handoff-renderer.ts
 import { join as join14 } from "path";
 
@@ -5670,13 +6002,36 @@ function isTrailingStale(latestActivityAt, recordedAt) {
   if (latestActivityAt === null) return false;
   return Date.parse(latestActivityAt) - Date.parse(recordedAt) > DECISION_TRAILING_ACTIVITY_GAP_MS;
 }
-function pickLatestSubstantiveEntry(entries) {
-  return [...entries].sort((a, b) => {
-    const aSubstantive = (a.session.session.related_files?.length ?? 0) > 0 ? 1 : 0;
-    const bSubstantive = (b.session.session.related_files?.length ?? 0) > 0 ? 1 : 0;
-    if (aSubstantive !== bSubstantive) return bSubstantive - aSubstantive;
-    return Date.parse(b.session.session.started_at) - Date.parse(a.session.session.started_at);
-  })[0];
+var WRAPPER_SESSION_COMMAND_COUNT = 1;
+function pickLatestSubstantiveEntry(entries, commandCounts, unmeasured) {
+  const didWork = (e) => {
+    if ((e.session.session.related_files?.length ?? 0) > 0) return true;
+    if (unmeasured.has(e.sessionId)) return true;
+    return (commandCounts.get(e.sessionId) ?? 0) > WRAPPER_SESSION_COMMAND_COUNT;
+  };
+  const working = entries.filter(didWork);
+  const outermost = working.filter((e) => !isNestedInAnother(e, working));
+  const pool = outermost.length > 0 ? outermost : working.length > 0 ? working : entries;
+  return [...pool].sort(
+    (a, b) => Date.parse(b.session.session.started_at) - Date.parse(a.session.session.started_at)
+  )[0];
+}
+function isNestedInAnother(entry, working) {
+  const end = entry.session.session.ended_at;
+  if (end === void 0) return false;
+  const start = Date.parse(entry.session.session.started_at);
+  const finish = Date.parse(end);
+  if (!Number.isFinite(start) || !Number.isFinite(finish)) return false;
+  return working.some((other) => {
+    if (other.sessionId === entry.sessionId) return false;
+    const otherEnd = other.session.session.ended_at;
+    if (otherEnd === void 0) return false;
+    const oStart = Date.parse(other.session.session.started_at);
+    const oFinish = Date.parse(otherEnd);
+    if (!Number.isFinite(oStart) || !Number.isFinite(oFinish)) return false;
+    if (oStart > start || oFinish < finish) return false;
+    return oStart < start || oFinish > finish;
+  });
 }
 
 // src/lib/transient-paths.ts
@@ -5720,6 +6075,8 @@ async function renderHandoff(input) {
   const tasksCreated = [];
   const tasksStatusChanged = [];
   let latestActivityAt = null;
+  const commandCounts = /* @__PURE__ */ new Map();
+  const unmeasuredSessions = /* @__PURE__ */ new Set();
   const noteActivity = (iso) => {
     if (latestActivityAt === null || Date.parse(iso) > Date.parse(latestActivityAt)) {
       latestActivityAt = iso;
@@ -5750,6 +6107,8 @@ async function renderHandoff(input) {
               sessionId: entry.sessionId
             });
           }
+        } else if (ev.type === "command_executed") {
+          commandCounts.set(entry.sessionId, (commandCounts.get(entry.sessionId) ?? 0) + 1);
         } else if (ev.type === "decision_voided") {
           voidedDecisionIds.add(ev.decision_id);
         } else if (ev.type === "task_created") {
@@ -5768,6 +6127,7 @@ async function renderHandoff(input) {
         }
       }
     } catch {
+      unmeasuredSessions.add(entry.sessionId);
       if (!unreadableEmitted.has(entry.sessionId)) {
         wrappedSkip(entry.sessionId, "events_jsonl_unreadable");
       }
@@ -5821,7 +6181,7 @@ async function renderHandoff(input) {
   const liveEntries = entries.filter(
     (e) => e.session.session.status !== "archived" && e.session.session.source.kind !== "import"
   );
-  const latestSession = pickLatestSubstantiveEntry(liveEntries);
+  const latestSession = pickLatestSubstantiveEntry(liveEntries, commandCounts, unmeasuredSessions);
   const latestFiles = (latestSession?.session.session.related_files ?? []).filter(
     (file) => !isTransientToolPath(file)
   );
@@ -6070,7 +6430,7 @@ function parseBuildStamp(raw) {
   }
 }
 var BASOU_CORE_BUILD = parseBuildStamp(
-  true ? '{"version":"0.48.1","commit":"bb3398c","committedAt":"2026-09-21T21:38:14+09:00"}' : void 0
+  true ? '{"version":"0.50.0","commit":"5b4c5dc","committedAt":"2026-09-23T19:12:06+09:00"}' : void 0
 );
 
 // src/lib/duration.ts
@@ -6280,6 +6640,8 @@ async function summarizeOrientation(input) {
   let latestActivityAt = null;
   let taskCreatedSeen = false;
   let latestNote = null;
+  const commandCounts = /* @__PURE__ */ new Map();
+  const unmeasuredSessions = /* @__PURE__ */ new Set();
   const noteActivity = (iso) => {
     if (latestActivityAt === null || Date.parse(iso) > Date.parse(latestActivityAt)) {
       latestActivityAt = iso;
@@ -6329,6 +6691,8 @@ async function summarizeOrientation(input) {
           taskCreatedSeen = true;
         } else if (ev.type === "decision_voided") {
           voidedDecisionIds.add(ev.decision_id);
+        } else if (ev.type === "command_executed") {
+          commandCounts.set(entry.sessionId, (commandCounts.get(entry.sessionId) ?? 0) + 1);
         }
         if (counted && ev.type === "note_added" && ev.kind === "next_step") {
           recordDirection(entry.sessionId, "note", ev.body);
@@ -6344,6 +6708,7 @@ async function summarizeOrientation(input) {
         if (counted) noteActivity(ev.occurred_at);
       }
     } catch {
+      unmeasuredSessions.add(entry.sessionId);
       input.onSessionSkip?.(entry.sessionId, "events_jsonl_unreadable");
     }
   }
@@ -6437,7 +6802,7 @@ async function summarizeOrientation(input) {
   const liveEntries = entries.filter(
     (e) => e.session.session.status !== "archived" && e.session.session.source.kind !== "import"
   );
-  const latestEntry = pickLatestSubstantiveEntry(liveEntries);
+  const latestEntry = pickLatestSubstantiveEntry(liveEntries, commandCounts, unmeasuredSessions);
   const latestSession = latestEntry !== void 0 ? {
     sessionId: latestEntry.sessionId,
     label: latestEntry.session.session.label ?? null,
@@ -9486,7 +9851,7 @@ var ChildProcessRunner = class {
       if (killTimer !== null) clearTimeout(killTimer);
       options.signal?.removeEventListener("abort", onAbort);
     };
-    return new Promise((resolve4, reject) => {
+    return new Promise((resolve5, reject) => {
       child.once("error", (error) => {
         if (settled) return;
         settled = true;
@@ -9498,7 +9863,7 @@ var ChildProcessRunner = class {
         settled = true;
         cleanup();
         const ended_at = /* @__PURE__ */ new Date();
-        resolve4({
+        resolve5({
           command: snapshotCommand,
           args: snapshotArgs,
           cwd: snapshotCwd,
@@ -9613,30 +9978,190 @@ function serializeJsonSchema(schema) {
 `;
 }
 
-// src/storage/basou-dir.ts
-import { lstat as lstat4, mkdir as mkdir4 } from "fs/promises";
+// src/session/observation.ts
+import { mkdir as mkdir4, readFile as readFile10 } from "fs/promises";
 import { join as join20 } from "path";
+import { z as z12 } from "zod";
+var SESSION_OBSERVATION_SCHEMA_VERSION = "0.1.0";
+var ObservedFileSchema = z12.object({
+  /** Absolute path, matching the paths the transcript importer records. */
+  path: z12.string().min(1),
+  change_type: z12.enum(["added", "modified", "deleted", "renamed"]),
+  old_path: z12.string().min(1).optional()
+});
+var ObservedRepoSchema = z12.object({
+  /** Absolute path of the git repository root this entry speaks for. */
+  path: z12.string().min(1),
+  /**
+   * `HEAD` as it stood when the session started. `null` when the repository
+   * had no commits yet (a fresh `git init`), in which case only working-tree
+   * changes are observable.
+   */
+  base_head: z12.string().nullable(),
+  /**
+   * Paths already dirty at session start. They are SUBTRACTED from the
+   * working-tree observation: a file the operator left modified before the
+   * session opened was not changed BY this session, and attributing it would
+   * make the first session after any interrupted work claim the interruption.
+   */
+  base_dirty: z12.array(z12.string()).default([]),
+  /** Latest full recomputation for this repository (see `observeSession`). */
+  files: z12.array(ObservedFileSchema).default([])
+});
+var SessionObservationSchema = z12.object({
+  schema_version: z12.string().min(1),
+  external_id: z12.string().min(1),
+  started_at: z12.string().min(1),
+  updated_at: z12.string().min(1),
+  repos: z12.array(ObservedRepoSchema).default([])
+});
+var SAFE_EXTERNAL_ID = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+function sessionObservationPath(observationsDir, externalId) {
+  if (!SAFE_EXTERNAL_ID.test(externalId)) return null;
+  if (externalId === "." || externalId === "..") return null;
+  return join20(observationsDir, `${externalId}.json`);
+}
+async function readSessionObservation(observationsDir, externalId) {
+  const file = sessionObservationPath(observationsDir, externalId);
+  if (file === null) return null;
+  let raw;
+  try {
+    raw = await readFile10(file, "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const result = SessionObservationSchema.safeParse(parsed);
+  if (!result.success) return null;
+  if (result.data.schema_version !== SESSION_OBSERVATION_SCHEMA_VERSION) return null;
+  return result.data;
+}
+async function writeSessionObservation(observationsDir, observation) {
+  const file = sessionObservationPath(observationsDir, observation.external_id);
+  if (file === null) return;
+  await mkdir4(observationsDir, { recursive: true });
+  await atomicReplace(file, `${JSON.stringify(observation, null, 2)}
+`);
+}
+function observedFilesOf(observation) {
+  const files = [];
+  for (const repo of observation.repos) files.push(...repo.files);
+  return files.sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+function observedFileFrom(repoRoot, change) {
+  return {
+    path: join20(repoRoot, change.path),
+    change_type: change.status,
+    ...change.old_path !== void 0 ? { old_path: join20(repoRoot, change.old_path) } : {}
+  };
+}
+
+// src/session/observe.ts
+import { resolve as resolve4 } from "path";
+function observedRepoRoots(root, manifest) {
+  const declared = manifest.repos ?? [];
+  const roots = declared.length > 0 ? declared.map((repo) => resolve4(root, repo.path)) : [root];
+  return [...new Set(roots)];
+}
+async function recordSessionBaseline(input) {
+  const existing = await readSessionObservation(input.observationsDir, input.externalId);
+  if (existing !== null) return existing;
+  const repos = [];
+  for (const repoRoot of input.repoRoots) {
+    let baseHead;
+    try {
+      baseHead = await readHeadSha(repoRoot);
+    } catch {
+      continue;
+    }
+    let baseDirty = [];
+    try {
+      baseDirty = (await getWorkingTreeChanges(repoRoot)).map(
+        (change) => observedFileFrom(repoRoot, change).path
+      );
+    } catch {
+    }
+    repos.push({ path: repoRoot, base_head: baseHead, base_dirty: baseDirty, files: [] });
+  }
+  if (repos.length === 0) return null;
+  const observation = {
+    schema_version: SESSION_OBSERVATION_SCHEMA_VERSION,
+    external_id: input.externalId,
+    started_at: input.nowIso,
+    updated_at: input.nowIso,
+    repos
+  };
+  await writeSessionObservation(input.observationsDir, observation);
+  return observation;
+}
+async function observeSessionChanges(input) {
+  const existing = await readSessionObservation(input.observationsDir, input.externalId);
+  if (existing === null) return null;
+  const repos = [];
+  for (const repo of existing.repos) {
+    let files;
+    try {
+      files = await changedSinceBaseline(repo);
+    } catch {
+      repos.push(repo);
+      continue;
+    }
+    repos.push({ ...repo, files });
+  }
+  const updated = { ...existing, updated_at: input.nowIso, repos };
+  await writeSessionObservation(input.observationsDir, updated);
+  return updated;
+}
+function isBasouStorePath(relativePath) {
+  return relativePath === ".basou" || relativePath.startsWith(".basou/");
+}
+async function changedSinceBaseline(repo) {
+  const byPath = /* @__PURE__ */ new Map();
+  const base = repo.base_head ?? await readEmptyTreeSha(repo.path);
+  for (const change of await getChangesSince(repo.path, base)) {
+    if (isBasouStorePath(change.path)) continue;
+    const file = observedFileFrom(repo.path, change);
+    byPath.set(file.path, file);
+  }
+  for (const change of await getUntrackedFiles(repo.path)) {
+    if (isBasouStorePath(change.path)) continue;
+    const file = observedFileFrom(repo.path, change);
+    if (!byPath.has(file.path)) byPath.set(file.path, file);
+  }
+  const preexisting = new Set(repo.base_dirty);
+  return [...byPath.values()].filter((file) => !preexisting.has(file.path)).sort((a, b) => a.path < b.path ? -1 : a.path > b.path ? 1 : 0);
+}
+
+// src/storage/basou-dir.ts
+import { lstat as lstat4, mkdir as mkdir5 } from "fs/promises";
+import { join as join21 } from "path";
 function basouPaths(repositoryRoot) {
-  const root = join20(repositoryRoot, ".basou");
-  const approvalsBase = join20(root, "approvals");
+  const root = join21(repositoryRoot, ".basou");
+  const approvalsBase = join21(root, "approvals");
   return {
     root,
-    sessions: join20(root, "sessions"),
-    tasks: join20(root, "tasks"),
+    sessions: join21(root, "sessions"),
+    tasks: join21(root, "tasks"),
     approvals: {
-      pending: join20(approvalsBase, "pending"),
-      resolved: join20(approvalsBase, "resolved")
+      pending: join21(approvalsBase, "pending"),
+      resolved: join21(approvalsBase, "resolved")
     },
-    locks: join20(root, "locks"),
-    logs: join20(root, "logs"),
-    raw: join20(root, "raw"),
-    tmp: join20(root, "tmp"),
+    locks: join21(root, "locks"),
+    logs: join21(root, "logs"),
+    raw: join21(root, "raw"),
+    tmp: join21(root, "tmp"),
+    observations: join21(root, "tmp", "observations"),
     files: {
-      manifest: join20(root, "manifest.yaml"),
-      status: join20(root, "status.json"),
-      handoff: join20(root, "handoff.md"),
-      decisions: join20(root, "decisions.md"),
-      orientation: join20(root, "orientation.md")
+      manifest: join21(root, "manifest.yaml"),
+      status: join21(root, "status.json"),
+      handoff: join21(root, "handoff.md"),
+      decisions: join21(root, "decisions.md"),
+      orientation: join21(root, "orientation.md")
     }
   };
 }
@@ -9677,7 +10202,7 @@ async function ensureBasouDirectory(repositoryRoot) {
 }
 async function mkdirLabeled(target, label) {
   try {
-    await mkdir4(target, { recursive: true });
+    await mkdir5(target, { recursive: true });
   } catch (error) {
     if (hasErrorCode5(error) && (error.code === "ENOTDIR" || error.code === "EEXIST")) {
       throw new Error(`${label} exists but is not a directory`, { cause: error });
@@ -9692,17 +10217,17 @@ function hasErrorCode5(error) {
 }
 
 // src/storage/gitignore.ts
-import { readFile as readFile10, writeFile as writeFile2 } from "fs/promises";
-import { join as join21 } from "path";
+import { readFile as readFile11, writeFile as writeFile2 } from "fs/promises";
+import { join as join22 } from "path";
 var MARKER = "# Basou - default ignore";
 var BASOU_GITIGNORE_BLOCK = "# Basou - default ignore\n.basou/logs/\n.basou/raw/\n.basou/tmp/\n.basou/locks/\n.basou/status.json\n.basou/orientation.md\n.basou/sessions/*/events.jsonl\n.basou/sessions/*/artifacts/\n.basou/approvals/pending/\n.basou/approvals/resolved/\n\n# Basou - default commit\n# .basou/manifest.yaml\n# .basou/handoff.md\n# .basou/decisions.md\n# .basou/tasks/\n# .basou/sessions/*/session.yaml\n# .basou/sessions/*/transcript.md\n# .basou/sessions/*/changed-files.json\n";
 var BASOU_GITIGNORE_BLOCK_LOCAL_ONLY = "# Basou - default ignore\n# Local-only: basou's trail is never committed (personal/local state,\n# regenerable by re-importing from the agents' own logs). Recommended for\n# monitored repos and any workspace kept out of version control.\n.basou/\n";
 async function appendBasouGitignore(repositoryRoot, options = {}) {
-  const gitignorePath = join21(repositoryRoot, ".gitignore");
+  const gitignorePath = join22(repositoryRoot, ".gitignore");
   let body;
   let existed;
   try {
-    body = await readFile10(gitignorePath, "utf8");
+    body = await readFile11(gitignorePath, "utf8");
     existed = true;
   } catch (error) {
     if (hasErrorCode6(error) && error.code === "ENOENT") {
@@ -9745,9 +10270,9 @@ function hasErrorCode6(error) {
 }
 
 // src/storage/session-import.ts
-import { mkdir as mkdir5, readFile as readFile11, rm as rm2 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile12, rm as rm2 } from "fs/promises";
 import { homedir as homedir4 } from "os";
-import { join as join22 } from "path";
+import { join as join23 } from "path";
 async function importSessionFromJson(paths, manifest, payload, options) {
   if (options.taskIdOverride !== void 0 && !TaskIdSchema.safeParse(options.taskIdOverride).success) {
     throw new Error(`Invalid task_id: ${options.taskIdOverride}`);
@@ -9772,9 +10297,9 @@ async function importSessionFromJson(paths, manifest, payload, options) {
       pathSanitizeReport
     };
   }
-  const sessionDir = join22(paths.sessions, newSessionId);
+  const sessionDir = join23(paths.sessions, newSessionId);
   try {
-    await mkdir5(sessionDir, { recursive: true });
+    await mkdir6(sessionDir, { recursive: true });
   } catch (error) {
     throw new Error("Failed to create session directory", { cause: error });
   }
@@ -9786,7 +10311,7 @@ async function importSessionFromJson(paths, manifest, payload, options) {
     throw error;
   }
   try {
-    const sessionYamlPath = join22(sessionDir, "session.yaml");
+    const sessionYamlPath = join23(sessionDir, "session.yaml");
     await linkYamlFile(sessionYamlPath, withIntegrity(sessionRecord, chainResult));
   } catch (error) {
     await rm2(sessionDir, { recursive: true, force: true }).catch(() => void 0);
@@ -9954,7 +10479,7 @@ function reuseDerivedIds(priorDerived, freshDerived, sessionId) {
 async function reimportPreservingId(paths, manifest, priorSessionId, freshPayload, options = {}) {
   const sessionId = priorSessionId;
   const importSource = freshPayload.session.source.kind;
-  const sessionDir = join22(paths.sessions, priorSessionId);
+  const sessionDir = join23(paths.sessions, priorSessionId);
   const lock = options.dryRun === true ? null : await acquireLock(paths, "session", priorSessionId);
   try {
     const priorVerdict = await verifyEventsChain(paths, priorSessionId);
@@ -9999,10 +10524,10 @@ async function reimportPreservingId(paths, manifest, priorSessionId, freshPayloa
       session: preservedInner
     };
     if (options.dryRun !== true) {
-      const eventsPath = join22(sessionDir, "events.jsonl");
+      const eventsPath = join23(sessionDir, "events.jsonl");
       let priorEventsRaw = null;
       try {
-        priorEventsRaw = await readFile11(eventsPath);
+        priorEventsRaw = await readFile12(eventsPath);
       } catch (error) {
         if (!findErrorCode(error, "ENOENT")) {
           throw new Error("Failed to read events.jsonl", { cause: error });
@@ -10011,7 +10536,7 @@ async function reimportPreservingId(paths, manifest, priorSessionId, freshPayloa
       const chainResult = await writeEventsBulk(sessionDir, mergedEvents, { chain: true });
       try {
         await overwriteYamlFile(
-          join22(sessionDir, "session.yaml"),
+          join23(sessionDir, "session.yaml"),
           withIntegrity(updatedRecord, chainResult)
         );
       } catch (error) {
@@ -10035,7 +10560,7 @@ async function reimportPreservingId(paths, manifest, priorSessionId, freshPayloa
   }
 }
 async function rechainSessionInPlace(paths, sessionId, options = {}) {
-  const sessionDir = join22(paths.sessions, sessionId);
+  const sessionDir = join23(paths.sessions, sessionId);
   let lock;
   try {
     lock = await acquireLock(paths, "session", sessionId);
@@ -10068,10 +10593,10 @@ async function rechainSessionInPlace(paths, sessionId, options = {}) {
     if (verdict.status !== "unchained") {
       return { status: "skipped", reason: "tampered" };
     }
-    const eventsPath = join22(sessionDir, "events.jsonl");
+    const eventsPath = join23(sessionDir, "events.jsonl");
     let priorRaw;
     try {
-      priorRaw = await readFile11(eventsPath);
+      priorRaw = await readFile12(eventsPath);
     } catch (error) {
       throw new Error("Failed to read events.jsonl", { cause: error });
     }
@@ -10116,7 +10641,7 @@ async function rechainSessionInPlace(paths, sessionId, options = {}) {
     }
     try {
       await overwriteYamlFile(
-        join22(sessionDir, "session.yaml"),
+        join23(sessionDir, "session.yaml"),
         withIntegrity(record, { headHash: chainResult.headHash, count: chainResult.count })
       );
     } catch (error) {
@@ -10167,6 +10692,7 @@ export {
   REVIEW_RECORD_NO_INPUT_HINT,
   RiskLevelSchema,
   SESSION_IMPORT_SCHEMA_VERSION,
+  SESSION_OBSERVATION_SCHEMA_VERSION,
   SESSION_SCHEMA_VERSION,
   SESSION_START_HOOK_CONTEXT_LIMIT,
   SESSION_START_HOOK_MATCHER,
@@ -10231,20 +10757,27 @@ export {
   finalizeSessionYaml,
   findBasouSessionStartHook,
   findBasouStopHookCommand,
+  findClaudeSessionStartHooks,
   findDecisionGaps,
   findErrorCode,
   findReviewGaps,
   findUnbindableRepos,
+  findUnrecognizedSessionStart,
   formatDurationMs,
   genesisHash,
+  getChangesSince,
   getDiff,
   getSnapshot,
+  getWorkingTreeChanges,
   hasRetiredZeroDuration,
   importSessionFromJson,
   inspectChainTail,
   instructionMode,
+  isBasouOrientSessionStartCommand,
   isBasouSessionStartHookCommand,
   isBasouStopHookCommand,
+  isClaudeSessionStartHookCommand,
+  isClaudeSessionStartMalformed,
   isGitNotFound,
   isImportDerivedSource,
   isLazyExpired,
@@ -10259,6 +10792,9 @@ export {
   loadTaskEntries,
   normalizeRepoKey,
   normalizeRepoPath,
+  observeSessionChanges,
+  observedFilesOf,
+  observedRepoRoots,
   overwriteYamlFile,
   parseBuildStamp,
   parseDuration,
@@ -10277,9 +10813,11 @@ export {
   protocolSectionsFrom,
   protocolUpdateToken,
   readAllEvents,
+  readHeadSha,
   readManifest,
   readMarkdownFile,
   readObservedDuration,
+  readSessionObservation,
   readSessionYaml,
   readStatus,
   readTaskFile,
@@ -10289,8 +10827,10 @@ export {
   reconcileAllTasks,
   reconcileSourceRoots,
   reconcileTask,
+  recordSessionBaseline,
   refreshTaskLinkedSessions,
   reimportPreservingId,
+  removeClaudeSessionStartHook,
   removeMarkerSection,
   removeSessionStartHook,
   removeStopHook,
@@ -10323,6 +10863,7 @@ export {
   seedMarkers,
   serializeEventLine,
   serializeJsonSchema,
+  sessionObservationPath,
   sessionWorkStatsFromEvents,
   summarizeAdapterOutput,
   summarizeOrientation,
@@ -10337,6 +10878,7 @@ export {
   unknownManifestKeys,
   unstampedProtocolSectionsFrom,
   updateTaskStatusWithEvent,
+  upsertClaudeSessionStartHook,
   upsertSessionStartHook,
   upsertStopHook,
   verifyEventsChain,
@@ -10345,6 +10887,7 @@ export {
   writeManifest,
   writeMarkdownFile,
   writeObservedDuration,
+  writeSessionObservation,
   writeStatus,
   writeTaskFile,
   writeYamlFile