@basou/core 0.48.0 → 0.49.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));
   });
 }
 
@@ -913,6 +913,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),
@@ -5619,20 +5622,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 +5685,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 +5823,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 +5896,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 +5928,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 +5948,7 @@ async function renderHandoff(input) {
         }
       }
     } catch {
+      unmeasuredSessions.add(entry.sessionId);
       if (!unreadableEmitted.has(entry.sessionId)) {
         wrappedSkip(entry.sessionId, "events_jsonl_unreadable");
       }
@@ -5821,7 +6002,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 +6251,7 @@ function parseBuildStamp(raw) {
   }
 }
 var BASOU_CORE_BUILD = parseBuildStamp(
-  true ? '{"version":"0.48.0","commit":"2e8fee7","committedAt":"2026-09-21T11:35:12+09:00"}' : void 0
+  true ? '{"version":"0.49.0","commit":"6c4704a","committedAt":"2026-09-23T11:46:39+09:00"}' : void 0
 );
 
 // src/lib/duration.ts
@@ -6280,6 +6461,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 +6512,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 +6529,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 +6623,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 +9672,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 +9684,7 @@ var ChildProcessRunner = class {
         settled = true;
         cleanup();
         const ended_at = /* @__PURE__ */ new Date();
-        resolve4({
+        resolve5({
           command: snapshotCommand,
           args: snapshotArgs,
           cwd: snapshotCwd,
@@ -9613,30 +9799,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 +10023,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 +10038,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 +10091,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 +10118,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 +10132,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 +10300,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 +10345,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 +10357,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 +10381,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 +10414,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 +10462,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 +10513,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,
@@ -10237,8 +10584,10 @@ export {
   findUnbindableRepos,
   formatDurationMs,
   genesisHash,
+  getChangesSince,
   getDiff,
   getSnapshot,
+  getWorkingTreeChanges,
   hasRetiredZeroDuration,
   importSessionFromJson,
   inspectChainTail,
@@ -10259,6 +10608,9 @@ export {
   loadTaskEntries,
   normalizeRepoKey,
   normalizeRepoPath,
+  observeSessionChanges,
+  observedFilesOf,
+  observedRepoRoots,
   overwriteYamlFile,
   parseBuildStamp,
   parseDuration,
@@ -10277,9 +10629,11 @@ export {
   protocolSectionsFrom,
   protocolUpdateToken,
   readAllEvents,
+  readHeadSha,
   readManifest,
   readMarkdownFile,
   readObservedDuration,
+  readSessionObservation,
   readSessionYaml,
   readStatus,
   readTaskFile,
@@ -10289,6 +10643,7 @@ export {
   reconcileAllTasks,
   reconcileSourceRoots,
   reconcileTask,
+  recordSessionBaseline,
   refreshTaskLinkedSessions,
   reimportPreservingId,
   removeMarkerSection,
@@ -10323,6 +10678,7 @@ export {
   seedMarkers,
   serializeEventLine,
   serializeJsonSchema,
+  sessionObservationPath,
   sessionWorkStatsFromEvents,
   summarizeAdapterOutput,
   summarizeOrientation,
@@ -10345,6 +10701,7 @@ export {
   writeManifest,
   writeMarkdownFile,
   writeObservedDuration,
+  writeSessionObservation,
   writeStatus,
   writeTaskFile,
   writeYamlFile