@aaac/observability 0.1.13 → 0.1.15

package/dist/chunk-EKFRH7PX.js

@@ -0,0 +1,266 @@
+import {
+  DEFAULT_DB_PATH,
+  captureWorktree,
+  createPipeline,
+  emitHumanInstruction,
+  emitPromotionPr,
+  emitQualityGateResult,
+  evaluateMapping,
+  generateId,
+  loadEventMappingConfig,
+  worktreeAttributes
+} from "./chunk-3DXZNA3E.js";
+
+// src/cli/record-hook.ts
+import { mkdir, rename, unlink, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+var GIT_CONTEXT_COMMAND_RE = /\bgit\s+(?:commit|push|merge)\b/;
+var WORKTREE_CAPTURE_HOOKS = /* @__PURE__ */ new Set([
+  "afterfileedit",
+  "posttooluse",
+  "beforeshellexecution",
+  "sessionstart",
+  "sessionend",
+  "start",
+  "stop"
+]);
+var GIT_HOOK_NAMES = /* @__PURE__ */ new Set([
+  "pre-commit",
+  "post-commit",
+  "pre-push",
+  "post-merge",
+  "post-checkout"
+]);
+function defaultMappingConfigPath(dbPath) {
+  return join(dirname(dbPath), "config", "event-mapping.json");
+}
+function contextFilePath(dbPath) {
+  return join(dirname(dbPath), ".observ-context.json");
+}
+async function readStdin() {
+  if (process.stdin.isTTY) return "";
+  return new Promise((resolve) => {
+    let data = "";
+    let settled = false;
+    const finish = () => {
+      if (settled) return;
+      settled = true;
+      resolve(data);
+    };
+    try {
+      process.stdin.setEncoding("utf8");
+      process.stdin.on("data", (chunk) => {
+        data += chunk;
+      });
+      process.stdin.on("end", finish);
+      process.stdin.on("error", finish);
+      process.stdin.on("close", finish);
+      const t = setTimeout(finish, 1e3);
+      if (typeof t.unref === "function") t.unref();
+    } catch {
+      finish();
+    }
+  });
+}
+function parseHookInput(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed) return {};
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed !== null && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function asString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function asNumber(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim() !== "") {
+    const n = Number(value);
+    if (Number.isFinite(n)) return n;
+  }
+  return void 0;
+}
+function emitMappedSpans(collector, hook, rule, hookInput, sessionId, source, extraAttributes) {
+  const { spans, links } = evaluateMapping(rule, hookInput);
+  const linksBySpan = /* @__PURE__ */ new Map();
+  for (const link of links) {
+    const arr = linksBySpan.get(link.fromSpanId) ?? [];
+    arr.push({ targetSpanId: link.toSpanId, linkType: link.linkType });
+    linksBySpan.set(link.fromSpanId, arr);
+  }
+  const parentConversationId = hook === "subagentStart" ? asString(hookInput.parent_conversation_id) : void 0;
+  for (const span of spans) {
+    const attributes = { ...span.attributes };
+    if (sessionId) attributes["session_id"] = sessionId;
+    if (parentConversationId) {
+      attributes["parent_conversation_id"] = parentConversationId;
+    }
+    if (extraAttributes) Object.assign(attributes, extraAttributes);
+    collector.emit({
+      source,
+      eventType: span.eventType,
+      lifecycle: span.lifecycle,
+      spanId: span.spanId,
+      parentSpanId: span.parentSpanId,
+      attributes,
+      links: linksBySpan.get(span.spanId) ?? []
+    });
+  }
+  return spans.length;
+}
+function emitWorktree(collector, hook, cwd, sessionId, source, git, extraAttributes) {
+  if (!WORKTREE_CAPTURE_HOOKS.has(hook.toLowerCase())) return 0;
+  const snapshot = git ? captureWorktree(cwd, git) : captureWorktree(cwd);
+  if (!snapshot) return 0;
+  const attributes = worktreeAttributes(snapshot, sessionId || void 0);
+  if (extraAttributes) Object.assign(attributes, extraAttributes);
+  collector.emit({
+    source,
+    eventType: "promotion.worktree",
+    lifecycle: "instant",
+    attributes
+  });
+  return 1;
+}
+function emitGenericFallback(collector, hook, sessionId, source, extraAttributes) {
+  const eventType = (GIT_HOOK_NAMES.has(hook) ? "git." : "cursor.") + hook;
+  const attributes = { "hook.name": hook };
+  if (sessionId) attributes["session_id"] = sessionId;
+  if (extraAttributes) Object.assign(attributes, extraAttributes);
+  collector.emit({
+    source,
+    eventType,
+    lifecycle: "instant",
+    attributes
+  });
+  return 1;
+}
+function emitHumanEvents(collector, hook, hookInput, sessionId) {
+  let count = 0;
+  if (hook === "beforeSubmitPrompt") {
+    const prompt = asString(hookInput.prompt);
+    if (prompt !== void 0) {
+      const attachments = Array.isArray(hookInput.attachments) ? hookInput.attachments : [];
+      emitHumanInstruction(collector, { sessionId, prompt, attachments });
+      count += 1;
+    }
+  } else if (hook === "afterShellExecution") {
+    const command = asString(hookInput.command);
+    if (command !== void 0) {
+      const exitCode = asNumber(hookInput.exit_code) ?? asNumber(hookInput.exitCode) ?? 0;
+      const durationMs = asNumber(hookInput.duration);
+      if (emitQualityGateResult(collector, { sessionId, command, exitCode, durationMs })) {
+        count += 1;
+      }
+      const output = asString(hookInput.output) ?? "";
+      if (emitPromotionPr(collector, { sessionId, command, output })) {
+        count += 1;
+      }
+    }
+  }
+  return count;
+}
+async function manageContextFile(hook, hookInput, sessionId, dbPath) {
+  const command = asString(hookInput.command) ?? "";
+  const isGitContextCommand = GIT_CONTEXT_COMMAND_RE.test(command);
+  const file = contextFilePath(dbPath);
+  if (hook === "beforeShellExecution" && isGitContextCommand) {
+    await mkdir(dirname(file), { recursive: true });
+    const payload = JSON.stringify({
+      session_id: sessionId || null,
+      nonce: generateId(),
+      created_at_ms: Date.now()
+    }) + "\n";
+    const tmp = `${file}.${process.pid}.${generateId()}.tmp`;
+    await writeFile(tmp, payload, "utf8");
+    await rename(tmp, file);
+  } else if (hook === "afterShellExecution" && isGitContextCommand) {
+    await unlink(file).catch(() => {
+    });
+  }
+}
+async function runRecordHook(args) {
+  const { hook, hookInput, dbPath, mappingConfigPath } = args;
+  const source = args.source ?? "cursor-hook";
+  const sessionId = args.sessionId ?? asString(hookInput.conversation_id) ?? "";
+  const cwd = args.cwd ?? asString(hookInput.cwd) ?? process.cwd();
+  await manageContextFile(hook, hookInput, sessionId, dbPath).catch(() => {
+  });
+  let config;
+  try {
+    config = await loadEventMappingConfig(mappingConfigPath);
+  } catch {
+    config = void 0;
+  }
+  const rule = config?.mappings?.[hook];
+  let recorded = 0;
+  let fallback = false;
+  const { collector, sink } = createPipeline({ dbPath });
+  try {
+    if (rule) {
+      recorded += emitMappedSpans(
+        collector,
+        hook,
+        rule,
+        hookInput,
+        sessionId,
+        source,
+        args.extraAttributes
+      );
+    } else {
+      recorded += emitGenericFallback(
+        collector,
+        hook,
+        sessionId,
+        source,
+        args.extraAttributes
+      );
+      fallback = true;
+    }
+    recorded += emitHumanEvents(collector, hook, hookInput, sessionId);
+    try {
+      recorded += emitWorktree(
+        collector,
+        hook,
+        cwd,
+        sessionId,
+        source,
+        args.git,
+        args.extraAttributes
+      );
+    } catch {
+    }
+  } finally {
+    sink.close();
+  }
+  return { recorded, fallback };
+}
+async function handleRecordHook(hookName, options, _parentOpts) {
+  const hook = hookName ?? "unknown";
+  const dbPath = options.db ?? DEFAULT_DB_PATH;
+  const mappingConfigPath = options.mappingConfig ?? defaultMappingConfigPath(dbPath);
+  let result = { recorded: 0, fallback: false };
+  try {
+    const hookInput = parseHookInput(await readStdin());
+    result = await runRecordHook({ hook, hookInput, dbPath, mappingConfigPath });
+  } catch (err) {
+    process.stderr.write(
+      `record-hook: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  process.stdout.write(JSON.stringify(result) + "\n");
+}
+
+export {
+  defaultMappingConfigPath,
+  contextFilePath,
+  readStdin,
+  parseHookInput,
+  runRecordHook,
+  handleRecordHook
+};
+//# sourceMappingURL=chunk-EKFRH7PX.js.map

package/dist/chunk-EKFRH7PX.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/cli/record-hook.ts"],"sourcesContent":["/**\n * record-hook handler — stdin-aware Cursor/git hook recorder.\n *\n * This is the runtime entrypoint for `.cursor/hooks/observ-record.sh`. Unlike the\n * thin `record` command (scalar flags only), `record-hook`:\n *\n *   1. parses the hook JSON payload from stdin (conversation_id + hook-specific fields)\n *   2. loads `.agent-logs/config/event-mapping.json` and resolves the matching\n *      mapping rule into 3-axis spans + cross-axis links (evaluateMapping)\n *   3. injects session_id = conversation_id on every emitted event (correlation key\n *      with @aaac/runtime in-process events)\n *   4. emits human-interaction events (human.instruction / quality_gate.result /\n *      promotion.pr) for the relevant hooks\n *   5. manages the short-lived git context file `.agent-logs/.observ-context.json`\n *      (write on beforeShellExecution for git commit/push/merge, delete on\n *      afterShellExecution) so git hooks can correlate (read side: #115)\n *\n * It is strictly fail-open: any parse/IO/config error degrades to the generic\n * fallback recording (or a no-op) and never throws — recording must NEVER block\n * the underlying hook operation.\n *\n * Issue #114 / shift-left-event-mapping.md §6 (option B).\n */\nimport { mkdir, rename, unlink, writeFile } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\nimport {\n  createPipeline,\n  generateId,\n  DEFAULT_DB_PATH,\n  loadEventMappingConfig,\n  evaluateMapping,\n  emitHumanInstruction,\n  emitQualityGateResult,\n  emitPromotionPr,\n} from \"../index.js\";\nimport type { EventCollector } from \"../collector/event-collector.js\";\nimport type { AttrValue, CanonicalLink } from \"../types/canonical-event.js\";\nimport type { EventMappingConfig, EventMappingRule } from \"../event-mapping/types.js\";\nimport { captureWorktree, worktreeAttributes, type GitRunner } from \"./worktree.js\";\n\n// ── Constants ──────────────────────────────────────────────────────────────────\n\n/** git subcommands that warrant propagating session context to git hooks. */\nconst GIT_CONTEXT_COMMAND_RE = /\\bgit\\s+(?:commit|push|merge)\\b/;\n\n/**\n * Hook names (case-insensitive) after which the working-tree HEAD is captured\n * (#175 / WS-B): session open/close, after file edit / tool use, before shell\n * execution. Matched against the lower-cased hook name so Cursor and Claude\n * naming variants both resolve.\n */\nconst WORKTREE_CAPTURE_HOOKS = new Set([\n  \"afterfileedit\",\n  \"posttooluse\",\n  \"beforeshellexecution\",\n  \"sessionstart\",\n  \"sessionend\",\n  \"start\",\n  \"stop\",\n]);\n\n/** Hook names that map to git.* event types in the generic fallback. */\nconst GIT_HOOK_NAMES = new Set([\n  \"pre-commit\",\n  \"post-commit\",\n  \"pre-push\",\n  \"post-merge\",\n  \"post-checkout\",\n]);\n\n// ── Options ──────────────────────────────────────────────────────────────────\n\nexport interface RecordHookOptions {\n  mappingConfig?: string;\n  db?: string;\n}\n\n/** Parsed result of running the hook recorder (also written to stdout as JSON). */\nexport interface RecordHookResult {\n  /** Number of events emitted into the pipeline. */\n  recorded: number;\n  /** True when no mapping rule matched and the generic fallback was used. */\n  fallback: boolean;\n}\n\n// ── Path helpers ───────────────────────────────────────────────────────────────\n\n/** Default event-mapping config path, derived from the db directory. */\nexport function defaultMappingConfigPath(dbPath: string): string {\n  return join(dirname(dbPath), \"config\", \"event-mapping.json\");\n}\n\n/** Short-lived git context file path, derived from the db directory. */\nexport function contextFilePath(dbPath: string): string {\n  return join(dirname(dbPath), \".observ-context.json\");\n}\n\n// ── stdin parsing ────────────────────────────────────────────────────────────\n\n/**\n * Read the entire stdin stream as a string.\n * Resolves \"\" when stdin is a TTY (no payload) or on any error — the git-hook\n * path frequently provides no stdin, which must be handled gracefully (AC-1).\n */\nexport async function readStdin(): Promise<string> {\n  if (process.stdin.isTTY) return \"\";\n  return new Promise<string>((resolve) => {\n    let data = \"\";\n    let settled = false;\n    const finish = (): void => {\n      if (settled) return;\n      settled = true;\n      resolve(data);\n    };\n    try {\n      process.stdin.setEncoding(\"utf8\");\n      process.stdin.on(\"data\", (chunk) => {\n        data += chunk;\n      });\n      process.stdin.on(\"end\", finish);\n      process.stdin.on(\"error\", finish);\n      process.stdin.on(\"close\", finish);\n      // Safety net: never hang the hook if stdin is left open.\n      const t = setTimeout(finish, 1000);\n      if (typeof t.unref === \"function\") t.unref();\n    } catch {\n      finish();\n    }\n  });\n}\n\n/** Parse a stdin payload into an object; returns {} for empty/invalid JSON. */\nexport function parseHookInput(raw: string): Record<string, unknown> {\n  const trimmed = raw.trim();\n  if (!trimmed) return {};\n  try {\n    const parsed = JSON.parse(trimmed) as unknown;\n    return parsed !== null && typeof parsed === \"object\"\n      ? (parsed as Record<string, unknown>)\n      : {};\n  } catch {\n    return {};\n  }\n}\n\n// ── Field coercion ───────────────────────────────────────────────────────────\n\nfunction asString(value: unknown): string | undefined {\n  return typeof value === \"string\" && value.length > 0 ? value : undefined;\n}\n\nfunction asNumber(value: unknown): number | undefined {\n  if (typeof value === \"number\" && Number.isFinite(value)) return value;\n  if (typeof value === \"string\" && value.trim() !== \"\") {\n    const n = Number(value);\n    if (Number.isFinite(n)) return n;\n  }\n  return undefined;\n}\n\n// ── Emission ─────────────────────────────────────────────────────────────────\n\n/**\n * Emit the 3-axis spans + cross-axis links resolved from a mapping rule.\n * session_id (and parent_conversation_id on subagentStart) are injected on every\n * span so all hook-derived events share the correlation key.\n */\nfunction emitMappedSpans(\n  collector: EventCollector,\n  hook: string,\n  rule: EventMappingRule,\n  hookInput: Record<string, unknown>,\n  sessionId: string,\n  source: string,\n  extraAttributes?: Record<string, AttrValue>,\n): number {\n  const { spans, links } = evaluateMapping(rule, hookInput);\n\n  // Group resolved links by their source spanId so they can be attached to the\n  // emitting (source) event as CanonicalLink entries.\n  const linksBySpan = new Map<string, CanonicalLink[]>();\n  for (const link of links) {\n    const arr = linksBySpan.get(link.fromSpanId) ?? [];\n    arr.push({ targetSpanId: link.toSpanId, linkType: link.linkType });\n    linksBySpan.set(link.fromSpanId, arr);\n  }\n\n  const parentConversationId =\n    hook === \"subagentStart\" ? asString(hookInput.parent_conversation_id) : undefined;\n\n  for (const span of spans) {\n    const attributes: Record<string, AttrValue> = { ...span.attributes };\n    if (sessionId) attributes[\"session_id\"] = sessionId;\n    if (parentConversationId) {\n      attributes[\"parent_conversation_id\"] = parentConversationId;\n    }\n    if (extraAttributes) Object.assign(attributes, extraAttributes);\n    collector.emit({\n      source,\n      eventType: span.eventType,\n      lifecycle: span.lifecycle,\n      spanId: span.spanId,\n      parentSpanId: span.parentSpanId,\n      attributes,\n      links: linksBySpan.get(span.spanId) ?? [],\n    });\n  }\n\n  return spans.length;\n}\n\n/**\n * Emit a `promotion.worktree` instant span capturing the working HEAD (#175).\n *\n * Best-effort + fail-open: skips silently when the cwd is not a git repo or any\n * git/IO error occurs. The session_id (resolved upstream) is carried so the\n * Enricher can attribute later out-of-band commits to the active session.\n */\nfunction emitWorktree(\n  collector: EventCollector,\n  hook: string,\n  cwd: string,\n  sessionId: string,\n  source: string,\n  git: GitRunner | undefined,\n  extraAttributes?: Record<string, AttrValue>,\n): number {\n  if (!WORKTREE_CAPTURE_HOOKS.has(hook.toLowerCase())) return 0;\n\n  const snapshot = git ? captureWorktree(cwd, git) : captureWorktree(cwd);\n  if (!snapshot) return 0;\n\n  const attributes = worktreeAttributes(snapshot, sessionId || undefined);\n  if (extraAttributes) Object.assign(attributes, extraAttributes);\n  collector.emit({\n    source,\n    eventType: \"promotion.worktree\",\n    lifecycle: \"instant\",\n    attributes,\n  });\n  return 1;\n}\n\n/**\n * Emit a single generic instant event (current pre-#114 behaviour) when no\n * mapping rule matches — preserves fail-open recording (AC-3).\n */\nfunction emitGenericFallback(\n  collector: EventCollector,\n  hook: string,\n  sessionId: string,\n  source: string,\n  extraAttributes?: Record<string, AttrValue>,\n): number {\n  const eventType = (GIT_HOOK_NAMES.has(hook) ? \"git.\" : \"cursor.\") + hook;\n  const attributes: Record<string, AttrValue> = { \"hook.name\": hook };\n  if (sessionId) attributes[\"session_id\"] = sessionId;\n  if (extraAttributes) Object.assign(attributes, extraAttributes);\n  collector.emit({\n    source,\n    eventType,\n    lifecycle: \"instant\",\n    attributes,\n  });\n  return 1;\n}\n\n/** Emit human-interaction events for the relevant hooks (AC-5). */\nfunction emitHumanEvents(\n  collector: EventCollector,\n  hook: string,\n  hookInput: Record<string, unknown>,\n  sessionId: string,\n): number {\n  let count = 0;\n\n  if (hook === \"beforeSubmitPrompt\") {\n    const prompt = asString(hookInput.prompt);\n    if (prompt !== undefined) {\n      const attachments = Array.isArray(hookInput.attachments)\n        ? (hookInput.attachments as unknown[])\n        : [];\n      emitHumanInstruction(collector, { sessionId, prompt, attachments });\n      count += 1;\n    }\n  } else if (hook === \"afterShellExecution\") {\n    const command = asString(hookInput.command);\n    if (command !== undefined) {\n      const exitCode = asNumber(hookInput.exit_code) ?? asNumber(hookInput.exitCode) ?? 0;\n      const durationMs = asNumber(hookInput.duration);\n      if (emitQualityGateResult(collector, { sessionId, command, exitCode, durationMs })) {\n        count += 1;\n      }\n      const output = asString(hookInput.output) ?? \"\";\n      if (emitPromotionPr(collector, { sessionId, command, output })) {\n        count += 1;\n      }\n    }\n  }\n\n  return count;\n}\n\n// ── Context file lifecycle ──────────────────────────────────────────────────\n\n/**\n * Manage the short-lived git context file (AC-4).\n *\n *   beforeShellExecution + git commit/push/merge → atomic write\n *   afterShellExecution  + git commit/push/merge → delete (fail-open)\n *\n * Atomic write uses write-to-temp + rename so a git hook never observes a\n * partially written file. Non-git commands never write the file.\n */\nasync function manageContextFile(\n  hook: string,\n  hookInput: Record<string, unknown>,\n  sessionId: string,\n  dbPath: string,\n): Promise<void> {\n  const command = asString(hookInput.command) ?? \"\";\n  const isGitContextCommand = GIT_CONTEXT_COMMAND_RE.test(command);\n  const file = contextFilePath(dbPath);\n\n  if (hook === \"beforeShellExecution\" && isGitContextCommand) {\n    await mkdir(dirname(file), { recursive: true });\n    const payload =\n      JSON.stringify({\n        session_id: sessionId || null,\n        nonce: generateId(),\n        created_at_ms: Date.now(),\n      }) + \"\\n\";\n    const tmp = `${file}.${process.pid}.${generateId()}.tmp`;\n    await writeFile(tmp, payload, \"utf8\");\n    await rename(tmp, file);\n  } else if (hook === \"afterShellExecution\" && isGitContextCommand) {\n    await unlink(file).catch(() => {\n      // rm -f semantics: missing file is not an error.\n    });\n  }\n}\n\n// ── Core (testable) ────────────────────────────────────────────────────────────\n\n/**\n * Run the hook recorder against an already-parsed hook input.\n *\n * Separated from {@link handleRecordHook} (which reads stdin) so it can be unit\n * tested without mocking process.stdin.\n */\nexport async function runRecordHook(args: {\n  hook: string;\n  hookInput: Record<string, unknown>;\n  dbPath: string;\n  mappingConfigPath: string;\n  /** Event source label (default \"cursor-hook\"; \"claude-hook\" for the Claude binding). */\n  source?: string;\n  /** Pre-resolved session_id; defaults to the hook payload's conversation_id. */\n  sessionId?: string;\n  /** Extra attributes injected on every emitted span (e.g. repo_id for the ledger). */\n  extraAttributes?: Record<string, AttrValue>;\n  /**\n   * Working directory used for promotion.worktree capture (#175). Defaults to the\n   * hook payload's `cwd`, then process.cwd().\n   */\n  cwd?: string;\n  /** Injectable git runner for worktree capture (testability). Defaults to real git. */\n  git?: GitRunner;\n}): Promise<RecordHookResult> {\n  const { hook, hookInput, dbPath, mappingConfigPath } = args;\n  const source = args.source ?? \"cursor-hook\";\n  const sessionId = args.sessionId ?? asString(hookInput.conversation_id) ?? \"\";\n  const cwd = args.cwd ?? asString(hookInput.cwd) ?? process.cwd();\n\n  // Context-file lifecycle is independent of recording and must not block it.\n  await manageContextFile(hook, hookInput, sessionId, dbPath).catch(() => {\n    // fail-open\n  });\n\n  // Load mapping config; absence/parse-error → generic fallback (AC-3).\n  let config: EventMappingConfig | undefined;\n  try {\n    config = await loadEventMappingConfig(mappingConfigPath);\n  } catch {\n    config = undefined;\n  }\n  const rule = config?.mappings?.[hook];\n\n  let recorded = 0;\n  let fallback = false;\n\n  // Enable the default enrichment rules (R1–R5) so hook-derived spans/links are\n  // enriched on the same SQLite-backed cache the runtime populates, allowing\n  // cross-axis (R5) linking across the process boundary (#143 / #140). The\n  // Enricher is fail-open, so a rule error never blocks the underlying hook.\n  const { collector, sink } = createPipeline({ dbPath });\n  try {\n    if (rule) {\n      recorded += emitMappedSpans(\n        collector,\n        hook,\n        rule,\n        hookInput,\n        sessionId,\n        source,\n        args.extraAttributes,\n      );\n    } else {\n      recorded += emitGenericFallback(\n        collector,\n        hook,\n        sessionId,\n        source,\n        args.extraAttributes,\n      );\n      fallback = true;\n    }\n    recorded += emitHumanEvents(collector, hook, hookInput, sessionId);\n    // Working-tree HEAD capture (#175). Best-effort + fail-open: a git/IO error\n    // must never block the underlying hook or the rest of the recording.\n    try {\n      recorded += emitWorktree(\n        collector,\n        hook,\n        cwd,\n        sessionId,\n        source,\n        args.git,\n        args.extraAttributes,\n      );\n    } catch {\n      // fail-open\n    }\n  } finally {\n    sink.close();\n  }\n\n  return { recorded, fallback };\n}\n\n// ── Handler ─────────────────────────────────────────────────────────────────\n\n/**\n * Handle `aaac-observ record-hook <hook-name>`.\n *\n * Reads the hook JSON from stdin, records the resolved events, and prints\n * `{ recorded, fallback }` to stdout. Strictly fail-open: never throws and\n * always returns; the calling shell wrapper additionally guarantees exit 0.\n */\nexport async function handleRecordHook(\n  hookName: string | undefined,\n  options: RecordHookOptions,\n  _parentOpts: Record<string, unknown>,\n): Promise<void> {\n  const hook = hookName ?? \"unknown\";\n  const dbPath = options.db ?? DEFAULT_DB_PATH;\n  const mappingConfigPath = options.mappingConfig ?? defaultMappingConfigPath(dbPath);\n\n  let result: RecordHookResult = { recorded: 0, fallback: false };\n  try {\n    const hookInput = parseHookInput(await readStdin());\n    result = await runRecordHook({ hook, hookInput, dbPath, mappingConfigPath });\n  } catch (err) {\n    // Recorder is fail-open: report to stderr but never block the operation.\n    process.stderr.write(\n      `record-hook: ${err instanceof Error ? err.message : String(err)}\\n`,\n    );\n  }\n\n  process.stdout.write(JSON.stringify(result) + \"\\n\");\n}\n"],"mappings":"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","names":[]}

package/dist/cli/global-record.d.ts

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+/** User-global ledger path, relative to HOME (`~/.aaac/ledger.db`). */
+declare function ledgerDbPath(home: string): string;
+interface GlobalRecordResult {
+    /** Where the event was recorded. */
+    scope: "project" | "ledger";
+    /** Absolute db path written to. */
+    dbPath: string;
+    /** Resolved project root, when scope === "project". */
+    projectRoot?: string;
+    /** repo_id attribute, when scope === "ledger". */
+    repoId?: string;
+    /** Resolved session id (may be "unknown" provisional). */
+    sessionId: string;
+    /** Events recorded into the pipeline. */
+    recorded: number;
+    /** True when the generic fallback was used (no mapping rule matched). */
+    fallback: boolean;
+}
+/**
+ * Compute a stable repo_id for the user-global ledger.
+ * Prefers a SHA-256 of the canonical git remote URL; falls back to a hash of the
+ * resolved cwd so records from a repo with no remote are still grouped.
+ */
+declare function computeRepoId(remoteUrl: string | undefined, fallbackPath: string): string;
+/** Best-effort canonical git remote URL for a directory; undefined on any error. */
+declare function gitRemoteUrl(cwd: string): string | undefined;
+interface RunGlobalRecordArgs {
+    hook: string;
+    hookInput: Record<string, unknown>;
+    source?: string;
+    /** Overrides for testability (default to the real environment). */
+    env?: Record<string, string | undefined>;
+    home?: string;
+    processCwd?: string;
+    /** Injectable remote-URL resolver (defaults to {@link gitRemoteUrl}). */
+    resolveRemote?: (cwd: string) => string | undefined;
+}
+/**
+ * Core (testable) global-record logic. Never throws — the caller guarantees
+ * exit 0 regardless of the outcome.
+ */
+declare function runGlobalRecord(args: RunGlobalRecordArgs): Promise<GlobalRecordResult>;
+interface ParsedArgs {
+    hook: string;
+    source?: string;
+}
+/** Parse `<hook-name> [--source <s>]` from argv (fail-open: unknown flags ignored). */
+declare function parseGlobalRecordArgs(argv: string[]): ParsedArgs;
+/** Run the wrapper end-to-end; always resolves (caller exits 0). */
+declare function main(argv?: string[]): Promise<void>;
+
+export { type GlobalRecordResult, type RunGlobalRecordArgs, computeRepoId, gitRemoteUrl, ledgerDbPath, main, parseGlobalRecordArgs, runGlobalRecord };

package/dist/cli/global-record.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+import {
+  contextFilePath,
+  defaultMappingConfigPath,
+  parseHookInput,
+  readStdin,
+  runRecordHook
+} from "../chunk-EKFRH7PX.js";
+import {
+  DEFAULT_DB_PATH
+} from "../chunk-3DXZNA3E.js";
+
+// src/cli/global-record.ts
+import { createHash } from "crypto";
+import { execFileSync } from "child_process";
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { homedir } from "os";
+import { join as join2 } from "path";
+
+// src/cli/session-id.ts
+var UNKNOWN_SESSION_ID = "unknown";
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function resolveSessionId(input = {}) {
+  const env = input.env ?? process.env;
+  const hookInput = input.hookInput ?? {};
+  const contextJson = input.contextJson ?? {};
+  const aaac = nonEmptyString(env.AAAC_SESSION_ID);
+  if (aaac) {
+    return { sessionId: aaac, source: "env-aaac", provisional: false };
+  }
+  const conversationId = nonEmptyString(hookInput.conversation_id);
+  if (conversationId) {
+    return { sessionId: conversationId, source: "conversation_id", provisional: false };
+  }
+  const fromContext = nonEmptyString(contextJson.session_id);
+  if (fromContext) {
+    return { sessionId: fromContext, source: "observ-context", provisional: false };
+  }
+  const claude = nonEmptyString(env.CLAUDE_SESSION_ID);
+  if (claude) {
+    return { sessionId: claude, source: "env-claude", provisional: false };
+  }
+  return { sessionId: UNKNOWN_SESSION_ID, source: "unknown", provisional: true };
+}
+
+// src/cli/walk-up.ts
+import { existsSync, statSync } from "fs";
+import { dirname, join, parse as parsePath, resolve } from "path";
+var PROJECT_MANIFEST = "project.yaml";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function collectCandidatePaths(input) {
+  const out = [];
+  const push = (value) => {
+    if (isNonEmptyString(value)) out.push(value);
+  };
+  push(input.cwd);
+  if (Array.isArray(input.workspaceRoots)) {
+    for (const root of input.workspaceRoots) push(root);
+  }
+  push(input.filePath);
+  push(input.processCwd ?? process.cwd());
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const p of out) {
+    const abs = resolve(p);
+    if (!seen.has(abs)) {
+      seen.add(abs);
+      result.push(abs);
+    }
+  }
+  return result;
+}
+function toStartDir(candidate) {
+  const abs = resolve(candidate);
+  try {
+    if (existsSync(abs) && statSync(abs).isDirectory()) {
+      return abs;
+    }
+  } catch {
+  }
+  return dirname(abs);
+}
+function walkUpForProject(startDir) {
+  let dir = toStartDir(startDir);
+  const { root } = parsePath(dir);
+  while (true) {
+    try {
+      if (existsSync(join(dir, PROJECT_MANIFEST))) {
+        return dir;
+      }
+    } catch {
+    }
+    if (dir === root) break;
+    const parent = dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return void 0;
+}
+function resolveProjectRoot(candidates) {
+  for (const candidate of candidates) {
+    const found = walkUpForProject(candidate);
+    if (found) return found;
+  }
+  return void 0;
+}
+
+// src/cli/global-record.ts
+function ledgerDbPath(home) {
+  return join2(home, ".aaac", "ledger.db");
+}
+function computeRepoId(remoteUrl, fallbackPath) {
+  const basis = remoteUrl && remoteUrl.trim().length > 0 ? `remote:${remoteUrl.trim()}` : `path:${fallbackPath}`;
+  return createHash("sha256").update(basis).digest("hex").slice(0, 16);
+}
+function readContextJson(dbPath) {
+  try {
+    const file = contextFilePath(dbPath);
+    if (!existsSync2(file)) return {};
+    const raw = readFileSync(file, "utf8");
+    return parseHookInput(raw);
+  } catch {
+    return {};
+  }
+}
+function gitRemoteUrl(cwd) {
+  try {
+    const out = execFileSync("git", ["-C", cwd, "config", "--get", "remote.origin.url"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      timeout: 2e3
+    });
+    const trimmed = out.trim();
+    return trimmed.length > 0 ? trimmed : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function runGlobalRecord(args) {
+  const { hook, hookInput } = args;
+  const env = args.env ?? process.env;
+  const home = args.home ?? homedir();
+  const processCwd = args.processCwd ?? process.cwd();
+  const source = args.source ?? "global-hook";
+  const resolveRemote = args.resolveRemote ?? gitRemoteUrl;
+  const candidates = collectCandidatePaths({
+    cwd: hookInput.cwd,
+    workspaceRoots: hookInput.workspace_roots,
+    filePath: hookInput.file_path,
+    processCwd
+  });
+  const projectRoot = resolveProjectRoot(candidates);
+  if (projectRoot) {
+    const dbPath2 = join2(projectRoot, DEFAULT_DB_PATH);
+    const contextJson2 = readContextJson(dbPath2);
+    const { sessionId: sessionId2 } = resolveSessionId({ hookInput, env, contextJson: contextJson2 });
+    const { recorded: recorded2, fallback: fallback2 } = await runRecordHook({
+      hook,
+      hookInput,
+      dbPath: dbPath2,
+      mappingConfigPath: defaultMappingConfigPath(dbPath2),
+      source,
+      sessionId: sessionId2
+    });
+    return { scope: "project", dbPath: dbPath2, projectRoot, sessionId: sessionId2, recorded: recorded2, fallback: fallback2 };
+  }
+  const dbPath = ledgerDbPath(home);
+  const contextJson = readContextJson(dbPath);
+  const { sessionId } = resolveSessionId({ hookInput, env, contextJson });
+  let remote;
+  try {
+    remote = resolveRemote(processCwd);
+  } catch {
+    remote = void 0;
+  }
+  const repoId = computeRepoId(remote, processCwd);
+  const extraAttributes = { repo_id: repoId };
+  const { recorded, fallback } = await runRecordHook({
+    hook,
+    hookInput,
+    dbPath,
+    mappingConfigPath: defaultMappingConfigPath(dbPath),
+    source,
+    sessionId,
+    extraAttributes
+  });
+  return { scope: "ledger", dbPath, repoId, sessionId, recorded, fallback };
+}
+function parseGlobalRecordArgs(argv) {
+  let hook = "unknown";
+  let source;
+  let sawHook = false;
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--source") {
+      source = argv[++i];
+    } else if (arg.startsWith("--source=")) {
+      source = arg.slice("--source=".length);
+    } else if (!arg.startsWith("-") && !sawHook) {
+      hook = arg;
+      sawHook = true;
+    }
+  }
+  return { hook, source };
+}
+async function main(argv = process.argv.slice(2)) {
+  let result;
+  try {
+    const { hook, source } = parseGlobalRecordArgs(argv);
+    const hookInput = parseHookInput(await readStdin());
+    result = await runGlobalRecord({ hook, hookInput, source });
+  } catch (err) {
+    process.stderr.write(
+      `global-record: ${err instanceof Error ? err.message : String(err)}
+`
+    );
+  }
+  if (result) {
+    process.stdout.write(JSON.stringify(result) + "\n");
+  }
+}
+if (process.argv[1] && process.argv[1].endsWith("global-record.js")) {
+  void main().finally(() => {
+    process.exit(0);
+  });
+}
+export {
+  computeRepoId,
+  gitRemoteUrl,
+  ledgerDbPath,
+  main,
+  parseGlobalRecordArgs,
+  runGlobalRecord
+};
+//# sourceMappingURL=global-record.js.map

package/dist/cli/global-record.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/cli/global-record.ts","../../src/cli/session-id.ts","../../src/cli/walk-up.ts"],"sourcesContent":["#!/usr/bin/env node\n/**\n * aaac-observ-global-record — user-global hook recorder (Issue #174 / T-A2).\n *\n * This is the binary wired into the USER-scope Cursor / Claude / Git hooks\n * installed by `aaac observability install --global`. Unlike `record-hook`\n * (which assumes it runs inside a configured repo with a known db path), this\n * wrapper is location-agnostic:\n *\n *   1. parse the hook JSON payload from stdin\n *   2. collect candidate paths (cwd / workspace_roots / file_path + process.cwd)\n *      and WALK UP to the nearest enclosing project.yaml\n *   3. resolve session_id through the multi-stage chain (AAAC_* → conversation_id\n *      → .observ-context.json → CLAUDE_* → unknown)\n *   4a. RESOLVED  → append to <project>/.agent-logs/observability.db\n *   4b. UNRESOLVED → append to ~/.aaac/ledger.db tagged with repo_id (a stable\n *       hash of the git remote URL, or the cwd when there is no remote)\n *\n * Strictly fail-open: every walk/IO/exception path still exits 0 so the wrapper\n * can NEVER block the underlying Cursor/Claude/Git operation.\n *\n * Proposal: docs/proposal/observability-integration.md §ローカルグローバル記録.\n */\nimport { createHash } from \"node:crypto\";\nimport { execFileSync } from \"node:child_process\";\nimport { existsSync, readFileSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { join } from \"node:path\";\nimport { DEFAULT_DB_PATH } from \"../index.js\";\nimport type { AttrValue } from \"../types/canonical-event.js\";\nimport {\n  contextFilePath,\n  defaultMappingConfigPath,\n  parseHookInput,\n  readStdin,\n  runRecordHook,\n} from \"./record-hook.js\";\nimport { resolveSessionId } from \"./session-id.js\";\nimport { collectCandidatePaths, resolveProjectRoot } from \"./walk-up.js\";\n\n/** User-global ledger path, relative to HOME (`~/.aaac/ledger.db`). */\nexport function ledgerDbPath(home: string): string {\n  return join(home, \".aaac\", \"ledger.db\");\n}\n\nexport interface GlobalRecordResult {\n  /** Where the event was recorded. */\n  scope: \"project\" | \"ledger\";\n  /** Absolute db path written to. */\n  dbPath: string;\n  /** Resolved project root, when scope === \"project\". */\n  projectRoot?: string;\n  /** repo_id attribute, when scope === \"ledger\". */\n  repoId?: string;\n  /** Resolved session id (may be \"unknown\" provisional). */\n  sessionId: string;\n  /** Events recorded into the pipeline. */\n  recorded: number;\n  /** True when the generic fallback was used (no mapping rule matched). */\n  fallback: boolean;\n}\n\n/**\n * Compute a stable repo_id for the user-global ledger.\n * Prefers a SHA-256 of the canonical git remote URL; falls back to a hash of the\n * resolved cwd so records from a repo with no remote are still grouped.\n */\nexport function computeRepoId(remoteUrl: string | undefined, fallbackPath: string): string {\n  const basis = remoteUrl && remoteUrl.trim().length > 0 ? `remote:${remoteUrl.trim()}` : `path:${fallbackPath}`;\n  return createHash(\"sha256\").update(basis).digest(\"hex\").slice(0, 16);\n}\n\n/** Read & parse `.observ-context.json` at the given db dir; fail-open to {}. */\nfunction readContextJson(dbPath: string): Record<string, unknown> {\n  try {\n    const file = contextFilePath(dbPath);\n    if (!existsSync(file)) return {};\n    const raw = readFileSync(file, \"utf8\");\n    return parseHookInput(raw);\n  } catch {\n    return {};\n  }\n}\n\n/** Best-effort canonical git remote URL for a directory; undefined on any error. */\nexport function gitRemoteUrl(cwd: string): string | undefined {\n  try {\n    const out = execFileSync(\"git\", [\"-C\", cwd, \"config\", \"--get\", \"remote.origin.url\"], {\n      encoding: \"utf8\",\n      stdio: [\"ignore\", \"pipe\", \"ignore\"],\n      timeout: 2000,\n    });\n    const trimmed = out.trim();\n    return trimmed.length > 0 ? trimmed : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nexport interface RunGlobalRecordArgs {\n  hook: string;\n  hookInput: Record<string, unknown>;\n  source?: string;\n  /** Overrides for testability (default to the real environment). */\n  env?: Record<string, string | undefined>;\n  home?: string;\n  processCwd?: string;\n  /** Injectable remote-URL resolver (defaults to {@link gitRemoteUrl}). */\n  resolveRemote?: (cwd: string) => string | undefined;\n}\n\n/**\n * Core (testable) global-record logic. Never throws — the caller guarantees\n * exit 0 regardless of the outcome.\n */\nexport async function runGlobalRecord(args: RunGlobalRecordArgs): Promise<GlobalRecordResult> {\n  const { hook, hookInput } = args;\n  const env = args.env ?? process.env;\n  const home = args.home ?? homedir();\n  const processCwd = args.processCwd ?? process.cwd();\n  const source = args.source ?? \"global-hook\";\n  const resolveRemote = args.resolveRemote ?? gitRemoteUrl;\n\n  const candidates = collectCandidatePaths({\n    cwd: hookInput.cwd,\n    workspaceRoots: hookInput.workspace_roots,\n    filePath: hookInput.file_path,\n    processCwd,\n  });\n  const projectRoot = resolveProjectRoot(candidates);\n\n  if (projectRoot) {\n    const dbPath = join(projectRoot, DEFAULT_DB_PATH);\n    const contextJson = readContextJson(dbPath);\n    const { sessionId } = resolveSessionId({ hookInput, env, contextJson });\n    const { recorded, fallback } = await runRecordHook({\n      hook,\n      hookInput,\n      dbPath,\n      mappingConfigPath: defaultMappingConfigPath(dbPath),\n      source,\n      sessionId,\n    });\n    return { scope: \"project\", dbPath, projectRoot, sessionId, recorded, fallback };\n  }\n\n  // Unresolved → user-global ledger, tagged with repo_id.\n  const dbPath = ledgerDbPath(home);\n  const contextJson = readContextJson(dbPath);\n  const { sessionId } = resolveSessionId({ hookInput, env, contextJson });\n  let remote: string | undefined;\n  try {\n    remote = resolveRemote(processCwd);\n  } catch {\n    remote = undefined; // fail-open: no remote → cwd-hash repo_id\n  }\n  const repoId = computeRepoId(remote, processCwd);\n  const extraAttributes: Record<string, AttrValue> = { repo_id: repoId };\n  const { recorded, fallback } = await runRecordHook({\n    hook,\n    hookInput,\n    dbPath,\n    mappingConfigPath: defaultMappingConfigPath(dbPath),\n    source,\n    sessionId,\n    extraAttributes,\n  });\n  return { scope: \"ledger\", dbPath, repoId, sessionId, recorded, fallback };\n}\n\n// ── CLI argument parsing ─────────────────────────────────────────────────────\n\ninterface ParsedArgs {\n  hook: string;\n  source?: string;\n}\n\n/** Parse `<hook-name> [--source <s>]` from argv (fail-open: unknown flags ignored). */\nexport function parseGlobalRecordArgs(argv: string[]): ParsedArgs {\n  let hook = \"unknown\";\n  let source: string | undefined;\n  let sawHook = false;\n  for (let i = 0; i < argv.length; i++) {\n    const arg = argv[i];\n    if (arg === \"--source\") {\n      source = argv[++i];\n    } else if (arg.startsWith(\"--source=\")) {\n      source = arg.slice(\"--source=\".length);\n    } else if (!arg.startsWith(\"-\") && !sawHook) {\n      hook = arg;\n      sawHook = true;\n    }\n  }\n  return { hook, source };\n}\n\n// ── Entrypoint ───────────────────────────────────────────────────────────────\n\n/** Run the wrapper end-to-end; always resolves (caller exits 0). */\nexport async function main(argv: string[] = process.argv.slice(2)): Promise<void> {\n  let result: GlobalRecordResult | undefined;\n  try {\n    const { hook, source } = parseGlobalRecordArgs(argv);\n    const hookInput = parseHookInput(await readStdin());\n    result = await runGlobalRecord({ hook, hookInput, source });\n  } catch (err) {\n    process.stderr.write(\n      `global-record: ${err instanceof Error ? err.message : String(err)}\\n`,\n    );\n  }\n  if (result) {\n    process.stdout.write(JSON.stringify(result) + \"\\n\");\n  }\n}\n\n// Only auto-run when invoked directly as a binary (not when imported by tests).\nif (process.argv[1] && process.argv[1].endsWith(\"global-record.js\")) {\n  void main().finally(() => {\n    // fail-open: ALWAYS exit 0.\n    process.exit(0);\n  });\n}\n","/**\n * session_id resolution — multi-stage, fail-open (Issue #174 / T-A6).\n *\n * The user-global hook path runs OUTSIDE the @aaac/runtime process and often\n * outside a configured repo, so the in-process correlation key (conversation_id\n * injected by record-hook) may be absent. To still correlate hook-derived spans\n * we resolve session_id through a fixed priority chain and, when every source\n * fails, fall back to a provisional `unknown` marker rather than dropping the\n * record (records must NEVER be lost — fail-open).\n *\n * Priority (highest first):\n *   1. AAAC_*            explicit env override (AAAC_SESSION_ID)\n *   2. conversation_id   hook payload field (Cursor / runtime correlation key)\n *   3. .observ-context.json   short-lived git-context file written by record-hook\n *   4. CLAUDE_*          Claude Code env (CLAUDE_SESSION_ID)\n *   5. unknown           provisional marker (provisional = true)\n *\n * Pure and synchronous: the caller is responsible for reading the (optional)\n * .observ-context.json contents and passing the parsed object. This keeps the\n * resolver trivially unit-testable per path (one test per priority level).\n *\n * Proposal: docs/proposal/observability-integration.md §session_id 解決.\n */\n\n/** Provisional marker used when no concrete session_id can be resolved. */\nexport const UNKNOWN_SESSION_ID = \"unknown\";\n\n/** Which priority rung produced the resolved session_id. */\nexport type SessionIdSource =\n  | \"env-aaac\"\n  | \"conversation_id\"\n  | \"observ-context\"\n  | \"env-claude\"\n  | \"unknown\";\n\nexport interface ResolveSessionIdInput {\n  /** Parsed hook payload from stdin (conversation_id, etc.). */\n  hookInput?: Record<string, unknown>;\n  /** Process environment (defaults to process.env). */\n  env?: Record<string, string | undefined>;\n  /** Parsed contents of `.observ-context.json` (read fail-open by the caller). */\n  contextJson?: Record<string, unknown>;\n}\n\nexport interface ResolvedSessionId {\n  /** Resolved session id, or {@link UNKNOWN_SESSION_ID} when unresolvable. */\n  sessionId: string;\n  /** The priority rung that produced the value. */\n  source: SessionIdSource;\n  /** True when no concrete source matched (sessionId === UNKNOWN_SESSION_ID). */\n  provisional: boolean;\n}\n\n/** Return value when it is a non-empty string, else undefined. */\nfunction nonEmptyString(value: unknown): string | undefined {\n  return typeof value === \"string\" && value.trim().length > 0 ? value : undefined;\n}\n\n/**\n * Resolve a session_id through the priority chain (1–5). Never throws.\n *\n * @returns the first matching source, or a provisional `unknown` marker.\n */\nexport function resolveSessionId(input: ResolveSessionIdInput = {}): ResolvedSessionId {\n  const env = input.env ?? process.env;\n  const hookInput = input.hookInput ?? {};\n  const contextJson = input.contextJson ?? {};\n\n  // 1. AAAC_* explicit override\n  const aaac = nonEmptyString(env.AAAC_SESSION_ID);\n  if (aaac) {\n    return { sessionId: aaac, source: \"env-aaac\", provisional: false };\n  }\n\n  // 2. conversation_id from the hook payload\n  const conversationId = nonEmptyString(hookInput.conversation_id);\n  if (conversationId) {\n    return { sessionId: conversationId, source: \"conversation_id\", provisional: false };\n  }\n\n  // 3. .observ-context.json (short-lived git-context file)\n  const fromContext = nonEmptyString(contextJson.session_id);\n  if (fromContext) {\n    return { sessionId: fromContext, source: \"observ-context\", provisional: false };\n  }\n\n  // 4. CLAUDE_* env\n  const claude = nonEmptyString(env.CLAUDE_SESSION_ID);\n  if (claude) {\n    return { sessionId: claude, source: \"env-claude\", provisional: false };\n  }\n\n  // 5. provisional unknown\n  return { sessionId: UNKNOWN_SESSION_ID, source: \"unknown\", provisional: true };\n}\n","/**\n * project.yaml walk-up resolution (Issue #174 / T-A2).\n *\n * The user-global hook records from any CWD, including repos that never ran\n * `aaac init`. To attribute a hook event to a project we walk UP the directory\n * tree from a set of candidate start paths (the hook payload's cwd /\n * workspace_roots / file_path, plus process.cwd()) until we find a `project.yaml`.\n *\n * Resolution rules:\n *   - The nearest enclosing project.yaml wins (innermost in a nested monorepo).\n *   - Candidates are tried in priority order; the first that resolves wins.\n *   - A file path is reduced to its containing directory before walking.\n *   - The walk stops at the filesystem root.\n *\n * Pure and fail-open: any stat/IO error on a candidate is swallowed and the next\n * candidate is tried; an empty/!found result is a normal outcome (the caller\n * then records to the user-global ledger).\n *\n * Proposal: docs/proposal/observability-integration.md §ローカルグローバル記録.\n */\nimport { existsSync, statSync } from \"node:fs\";\nimport { dirname, join, parse as parsePath, resolve } from \"node:path\";\n\n/** The project manifest filename that anchors a project root. */\nexport const PROJECT_MANIFEST = \"project.yaml\";\n\nexport interface CollectCandidatesInput {\n  /** Hook payload `cwd` field. */\n  cwd?: unknown;\n  /** Hook payload `workspace_roots` field (array of paths). */\n  workspaceRoots?: unknown;\n  /** Hook payload `file_path` field (the edited file). */\n  filePath?: unknown;\n  /** Process cwd fallback (defaults to process.cwd()). */\n  processCwd?: string;\n}\n\nfunction isNonEmptyString(value: unknown): value is string {\n  return typeof value === \"string\" && value.trim().length > 0;\n}\n\n/**\n * Collect ordered, de-duplicated candidate start directories from a hook payload.\n * Priority: cwd → workspace_roots (in order) → file_path → process.cwd().\n */\nexport function collectCandidatePaths(input: CollectCandidatesInput): string[] {\n  const out: string[] = [];\n  const push = (value: unknown): void => {\n    if (isNonEmptyString(value)) out.push(value);\n  };\n\n  push(input.cwd);\n  if (Array.isArray(input.workspaceRoots)) {\n    for (const root of input.workspaceRoots) push(root);\n  }\n  push(input.filePath);\n  push(input.processCwd ?? process.cwd());\n\n  // De-duplicate by resolved absolute path while preserving order.\n  const seen = new Set<string>();\n  const result: string[] = [];\n  for (const p of out) {\n    const abs = resolve(p);\n    if (!seen.has(abs)) {\n      seen.add(abs);\n      result.push(abs);\n    }\n  }\n  return result;\n}\n\n/** Reduce a path to a directory: a file → its parent, a dir → itself. */\nfunction toStartDir(candidate: string): string {\n  const abs = resolve(candidate);\n  try {\n    if (existsSync(abs) && statSync(abs).isDirectory()) {\n      return abs;\n    }\n  } catch {\n    // fall through — treat as a (possibly non-existent) file path\n  }\n  return dirname(abs);\n}\n\n/**\n * Walk up from a single start directory to the nearest enclosing project.yaml.\n * @returns the directory containing project.yaml, or undefined.\n */\nexport function walkUpForProject(startDir: string): string | undefined {\n  let dir = toStartDir(startDir);\n  const { root } = parsePath(dir);\n\n  // Bounded by the filesystem root; the loop terminates because dirname()\n  // is a fixed point at the root.\n  // eslint-disable-next-line no-constant-condition\n  while (true) {\n    try {\n      if (existsSync(join(dir, PROJECT_MANIFEST))) {\n        return dir;\n      }\n    } catch {\n      // ignore and keep climbing\n    }\n    if (dir === root) break;\n    const parent = dirname(dir);\n    if (parent === dir) break;\n    dir = parent;\n  }\n  return undefined;\n}\n\n/**\n * Resolve a project root by walking up from each candidate path in priority\n * order. Returns the first project root found, or undefined when none of the\n * candidates is inside a project.\n */\nexport function resolveProjectRoot(candidates: string[]): string | undefined {\n  for (const candidate of candidates) {\n    const found = walkUpForProject(candidate);\n    if (found) return found;\n  }\n  return undefined;\n}\n"],"mappings":"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","names":["existsSync","join","join","existsSync","dbPath","contextJson","sessionId","recorded","fallback"]}