fix(attribution): Bug 8 — git -C <dir> scope hint flows to attribution

Reported alongside Bug 7 ("CRITICAL cross-project attribution"). Empirical
repro found Bug 7 is NOT a bug — existing EVENT_PATH + bridge
resolveProjectIdentity already attribute file_edit on /projB/foo.ts to
projB even when cwd=projA. Bug 8 IS a bug: Bash invocations that scope
via `-C <dir>` (git, make, tar) had no path signal in the canonical event
data and fell back to inputProjectDir (= hook startup cwd), missing the
user's intentional scoping.

ROOT CAUSE
extract.ts:extractGit only ran a regex pattern scan like /\bgit\s+commit\b/,
which doesn't tolerate flags between `git` and the operation. So
`git -C /projB status` returned NO git event AND no cwd hint. Even if a
cwd event had been emitted, the fallbackAttribution path in
project-attribution.ts:fallbackAttribution prefers context.inputProjectDir
over context.lastKnownProjectDir — so the carry-forward from a previous
cwd event in the same batch is silently overridden by the hook's startup
cwd.

FIX — TWO LAYERS, BOTH ALGORITHMIC (NO REGEX)

src/session/extract.ts: new parseGitInvocation() tokenises the Bash
command (reusing tokenizeCommand from v1.0.161 Bug 1 fix), skips env-style
assignments and common runners (sudo/doas/env/exec/time), locates the
`git` token, then scans for `-C` / `--directory` to capture scopedDir and
the first bare token as the operation. Falls back to the legacy regex
scan only when the algorithmic parse can't find a `git` token.

When scopedDir is captured, extractGit now emits a leading cwd event with
the parsed dir BEFORE the git event. The attribution layer then routes
the git event via carry-forward.

src/session/project-attribution.ts: resolveProjectAttributions tracks
whether an in-batch CWD-level event (confidence ≥ 0.9) has explicitly
re-scoped the project. Once true, subsequent events fall back to the
carried-forward lastKnown instead of the original hook inputProjectDir.
This is the architectural minimum needed for "user's intentional cwd
shift wins over hook startup cwd" without bumping CARRY_FORWARD_THRESHOLD
or reordering the fallbackAttribution priority globally (both of which
would have broader regression surface).

TESTS (tests/integration/cross-project-attribution.test.ts, 5 tests)
1. Tracer — Edit on projB's file while cwd=projA → projB ✅ (no-fix, existing path)
2. Batched mixed A+B+B edits → each event attributes independently ✅
3. Bug 8 tracer — `git -C /projB status` via real extractEvents → projB ✅
4. `cd /projB && npm test` (baseline that already worked) → projB ✅
5. Bash without path indicator (df -h) → fallback to cwd ✅

Empirical proof: live E2E against real platform — file_edit on projB,
cwd event, and git event all POST with project=github.com/acme/projB,
status 200 from production endpoint.

REGRESSION
1215 pass, 5 skipped, 1 pre-existing failure (project-dir-strict — stale,
unrelated). The attribution batch-shadow fix does not affect any
existing test fixture — the lastKnown shadowing only kicks in when a
CWD_EVENT-level confidence attribution has carried forward, which the
existing tests don't exercise in mixed batches.

NO release. Push to next only — waiting for user verification + approval.

Author: mksglu

src/session/extract.ts

@@ -340,7 +340,21 @@ function extractGit(input: HookInput): SessionEvent[] {
   if (input.tool_name !== "Bash") return [];
 
   const cmd = String(input.tool_input["command"] ?? "");
-  const match = GIT_PATTERNS.find(p => p.pattern.test(cmd));
+
+  // Bug 8 (v1.0.162) — parse the git invocation algorithmically so flags
+  // between `git` and the operation token are tolerated (`git -C /path
+  // status`, `git --no-pager log`, etc.). Falls back to the legacy regex
+  // pattern scan when the algorithmic parse cannot locate a `git` token —
+  // preserves backward compat for commands like `cd /repo && git status`
+  // where the algorithmic parse sees `cd` as the first token instead.
+  const parsed = parseGitInvocation(cmd);
+  let match: { pattern: RegExp; operation: string } | undefined;
+  if (parsed && parsed.operation) {
+    match = GIT_PATTERNS.find(p => p.operation === parsed.operation);
+  }
+  if (!match) {
+    match = GIT_PATTERNS.find(p => p.pattern.test(cmd));
+  }
   if (!match) return [];
 
   // Bug 1 (v1.0.161) — for `git commit` operations, parse -m / -am / --message=
@@ -354,24 +368,125 @@ function extractGit(input: HookInput): SessionEvent[] {
   // rollup aggregator can distinguish ACTUAL commits from other git operations
   // (status/diff/log were inflating has_commit on every event — see
   // session-loaders.mjs rollup stamp + Bug 2).
+  // Bug 8 cwd hint — when `-C <dir>` is present in the git invocation, emit
+  // a leading cwd event so the attribution carry-forward (LAST_SEEN source)
+  // routes downstream events in the same batch to the scoped directory's
+  // project. Without the hint, `git -C /projB status` while cwd=/projA
+  // misattributes to /projA.
+  const out: SessionEvent[] = [];
+  if (parsed?.scopedDir) {
+    out.push({
+      type: "cwd",
+      category: "cwd",
+      data: safeString(parsed.scopedDir),
+      priority: 2,
+    });
+  }
+
   if (match.operation === "commit") {
     const msg = extractCommitMessageFromCommand(cmd);
     if (msg) {
-      return [{
+      out.push({
         type: "git_commit",
         category: "git",
         data: safeString(msg),
         priority: 2,
-      }];
+      });
+      return out;
     }
   }
 
-  return [{
+  out.push({
     type: "git",
     category: "git",
     data: safeString(match.operation),
     priority: 2,
-  }];
+  });
+  return out;
+}
+
+// Algorithmic git invocation parser — tokenizes the Bash command and walks
+// argv to extract the `-C <dir>` scope hint and the operation subcommand.
+// Tolerates env-prefix assignments and any number of flags between `git`
+// and the operation. Returns null when no `git` token is found (caller
+// falls back to the legacy regex pattern scan).
+interface ParsedGit {
+  scopedDir: string | null;
+  operation: string | null;
+}
+
+function parseGitInvocation(cmd: string): ParsedGit | null {
+  const tokens = tokenizeCommand(cmd);
+  let i = 0;
+  // Skip env-style assignments at the head (FOO=bar git ...)
+  while (i < tokens.length && isEnvAssignment(tokens[i])) i++;
+  // Locate the `git` token (allow common runners like `sudo git ...`)
+  while (i < tokens.length && tokens[i] !== "git" && !tokens[i].endsWith("/git")) {
+    // Stop runner-skipping at the first non-assignment, non-runner token
+    if (!isCommonRunner(tokens[i])) break;
+    i++;
+  }
+  if (i >= tokens.length) return null;
+  if (tokens[i] !== "git" && !tokens[i].endsWith("/git")) return null;
+  i++; // consume `git`
+
+  let scopedDir: string | null = null;
+  let operation: string | null = null;
+  while (i < tokens.length) {
+    const t = tokens[i];
+    if (t === "-C" || t === "--directory") {
+      scopedDir = tokens[i + 1] ?? null;
+      i += 2;
+      continue;
+    }
+    if (t.length > 0 && t[0] === "-") {
+      // Generic flag — skip the flag itself. We do NOT consume the next
+      // token as its value generically because git's per-flag arg shape
+      // varies; the dedicated extractCommitMessageFromCommand handles -m
+      // separately.
+      i++;
+      continue;
+    }
+    // First bare (non-flag) token after `git` = operation
+    operation = t;
+    break;
+  }
+  return { scopedDir, operation };
+}
+
+function isEnvAssignment(token: string): boolean {
+  if (token.length === 0) return false;
+  // FOO=bar shape: starts with an uppercase letter, contains an `=`
+  let sawEq = false;
+  for (let j = 0; j < token.length; j++) {
+    const c = token.charCodeAt(j);
+    if (j === 0) {
+      // First char must be A-Z or underscore
+      if (!((c >= 65 && c <= 90) || c === 95)) return false;
+    } else if (c === 61 /* = */) {
+      sawEq = true;
+      break;
+    } else if (!((c >= 65 && c <= 90) || (c >= 48 && c <= 57) || c === 95)) {
+      // Body chars must be A-Z, 0-9, or _
+      return false;
+    }
+  }
+  return sawEq;
+}
+
+function isCommonRunner(token: string): boolean {
+  // Runners that wrap real commands. We skip them when locating `git`
+  // so `sudo git status` works the same as `git status`.
+  switch (token) {
+    case "sudo":
+    case "doas":
+    case "env":
+    case "exec":
+    case "time":
+      return true;
+    default:
+      return false;
+  }
 }
 
 // Shell-like argv tokenizer — handles single/double quotes, backslash escapes,

src/session/project-attribution.ts

@@ -249,16 +249,30 @@ export function resolveProjectAttributions(
 ): ProjectAttribution[] {
   const out: ProjectAttribution[] = [];
   let lastKnown = context.lastKnownProjectDir ? normalizePath(context.lastKnownProjectDir) : "";
+  // v1.0.162 Bug 8 — track whether an in-batch CWD-level event has explicitly
+  // re-scoped the project. When extract.ts emits a cwd event for `cd /projB`
+  // or `git -C /projB ...`, subsequent path-less events in the same batch
+  // (e.g. the git operation event itself) currently fall back to the hook's
+  // inputProjectDir, which still points at the session startup cwd. The
+  // user's INTENTIONAL scoping should win over the hook's startup cwd —
+  // shadow inputProjectDir with the carried-forward lastKnown once a high-
+  // confidence cwd event has fired in this batch.
+  let inBatchCwdScope = false;
 
   for (const ev of events) {
+    const effectiveInputCwd = inBatchCwdScope ? lastKnown : context.inputProjectDir;
     const attribution = resolveProjectAttribution(ev, {
       ...context,
+      inputProjectDir: effectiveInputCwd,
       lastKnownProjectDir: lastKnown || context.lastKnownProjectDir || null,
     });
     out.push(attribution);
 
     if (attribution.projectDir && attribution.confidence >= ATTRIBUTION_CONFIDENCE.CARRY_FORWARD_THRESHOLD) {
       lastKnown = attribution.projectDir;
+      if (attribution.confidence >= ATTRIBUTION_CONFIDENCE.CWD_EVENT) {
+        inBatchCwdScope = true;
+      }
     }
   }