session-orchestrator 3.22.0 → 3.24.0

package/scripts/lib/session-discovery.mjs

@@ -32,6 +32,28 @@
  *   - Lock takes precedence over registry (more detail per session); registry
  *     supplements missing per-worktree entries (e.g., when the hook ran but
  *     the prose Phase 1.2 acquire was skipped).
+ *   - A live local session.lock does NOT supersede same-repo registry entries
+ *     with a different raw session_id (GH#67 candidate fix, measured 2026-09-02
+ *     and NOT adopted): the session lock is advisory, so a second session can
+ *     and demonstrably does run in the same working copy without holding it.
+ *     Filtering those entries out hides genuine same-working-copy peers — the
+ *     #1085 semantic-alias boundary (tests/integration/session-identity-
+ *     boundaries.test.mjs) and 7 peer-discovery cases pin exactly that
+ *     visibility. Any GH#67 fix must discriminate finished-but-fresh entries
+ *     some other way; do not re-attempt lock-ownership supersession here.
+ *     See ADR-0014 (docs/adr/0014-peer-visibility-under-advisory-lock.md) for
+ *     the annotate-never-filter decision and the 9-test refutation of the
+ *     filtering alternative.
+ *   - The adopted GH#67 shape is therefore ADDITIVE ANNOTATION, never a filter.
+ *     Registry-sourced sessions carry `registryOnly: true` plus
+ *     `lockSuperseded` / `lockOwnerId`. `lockSuperseded: true` means: a LIVE
+ *     lock at this repoRoot is owned by a different raw session_id than this
+ *     registry entry. It is a HINT, not a verdict — the lock is advisory, so
+ *     the entry may still be a live session that lost the acquire race (#1085
+ *     contract). Consumers deciding a worktree-PROMOTION_OFFER downgrade such
+ *     a peer to an advisory line (GH#67); consumers counting or displaying
+ *     peers keep it. Lock-sourced sessions carry none of the three fields, so
+ *     their objects stay byte-identical to the pre-GH#67 shape.
  *
  * Timeout + A1 fallback:
  *   - listWorktrees() is raced against DEFAULT_DISCOVERY_TIMEOUT_MS (2 s).
@@ -46,6 +68,7 @@ import os from 'node:os';
 import { listWorktrees } from './worktree/listing.mjs';
 import { readLock, isLockLive } from './session-lock.mjs';
 import { readRegistry, repoPathHash, isRegistryEntryFresh } from './session-registry.mjs';
+import { stableHostname } from './host-identity.mjs';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -66,7 +89,7 @@ export const DEFAULT_DISCOVERY_TIMEOUT_MS = 2000;
  * @param {object} lock          Parsed lock body (schema v2).
  * @param {string} worktreePath  Absolute worktree path.
  * @param {string} [branch]      Branch from worktree object (falsy → '').
- * @returns {{worktreePath:string,sessionId:string,mode:string,startedAt:string,pid:number,host:string,branch:string}}
+ * @returns {{worktreePath:string,sessionId:string,mode:string,startedAt:string,pid:number,host:string,host_id:string,branch:string}}
  */
 function sessionFromLock(lock, worktreePath, branch = '') {
   return {
@@ -76,6 +99,12 @@ function sessionFromLock(lock, worktreePath, branch = '') {
     startedAt:    lock.started_at,
     pid:          lock.pid,
     host:         lock.host,
+    // Additive normalised twin (#1072), same field the registry path emits —
+    // without it the two discovery sources returned DIFFERENT shapes, and a
+    // consumer comparing hosts silently fell back to the raw `host` for
+    // lock-sourced sessions only. Locks written before #1072 carry no
+    // `host_id`, so derive it from the raw name rather than emitting undefined.
+    host_id:      lock.host_id ?? stableHostname(lock.host),
     branch:       typeof branch === 'string' ? branch : '',
   };
 }
@@ -86,10 +115,24 @@ function sessionFromLock(lock, worktreePath, branch = '') {
  * does not record per-worktree paths — only repo-path-hashes. Branch is
  * passed through from the registry entry when available.
  *
+ * GH#67 annotation (additive, never a filter — see the module header): every
+ * registry-sourced session carries `registryOnly: true` and the pair
+ * `lockSuperseded` / `lockOwnerId`. `lockSuperseded: true` says a LIVE lock at
+ * this repoRoot is owned by a DIFFERENT raw session_id than this entry — a
+ * HINT that the entry may be a finished-but-still-fresh task (the GH#67 case:
+ * Codex emits no SessionEnd, so the registry entry outlives the task by up to
+ * `freshnessMin`). It is not a verdict: the lock is advisory, so the entry may
+ * equally be a live session that never acquired it (#1085). Consumers deciding
+ * a worktree PROMOTION_OFFER downgrade such a peer to an advisory line;
+ * consumers counting or displaying peers keep it unchanged.
+ *
  * @param {object} entry    Registry entry.
  * @param {string} repoRoot Discovery repoRoot (used as worktreePath fallback).
+ * @param {object} [ctx]
+ * @param {string|null} [ctx.lockOwnerId] Raw session_id owning a LIVE lock at
+ *   repoRoot, or null when there is no live local lock.
  */
-function sessionFromRegistryEntry(entry, repoRoot) {
+function sessionFromRegistryEntry(entry, repoRoot, { lockOwnerId = null } = {}) {
   return {
     worktreePath: repoRoot,
     sessionId:    entry.session_id,
@@ -100,7 +143,15 @@ function sessionFromRegistryEntry(entry, repoRoot) {
     // local hostname as the default since registry entries are host-scoped
     // by design (see ~/.config/session-orchestrator/sessions/).
     host:         os.hostname(),
+    // Additive normalised twin (#1072) — `os.hostname()` is not stable on a
+    // single machine, so consumers comparing hosts need the normalised form.
+    host_id:      stableHostname(),
     branch:       typeof entry.branch === 'string' ? entry.branch : '',
+    // GH#67 additive annotation (see the JSDoc above). Lock-sourced sessions
+    // deliberately carry none of these three fields.
+    registryOnly: true,
+    lockSuperseded: lockOwnerId !== null && entry.session_id !== lockOwnerId,
+    lockOwnerId,
   };
 }
 
@@ -111,7 +162,7 @@ function sessionFromRegistryEntry(entry, repoRoot) {
  * Liveness rule: heartbeat freshness via isLockLive (Epic #583, W2-I3).
  *
  * @param {string} repoRoot
- * @returns {Array<{worktreePath:string,sessionId:string,mode:string,startedAt:string,pid:number,host:string,branch:string}>}
+ * @returns {Array<{worktreePath:string,sessionId:string,mode:string,startedAt:string,pid:number,host:string,host_id:string,branch:string}>}
  */
 function readLocalSession(repoRoot) {
   const lock = readLock({ repoRoot });
@@ -167,7 +218,10 @@ function dedupeBySessionId(sessions) {
  * @param {Function} [opts.registryReader]      DI hook replacing readRegistry() for tests.
  * @param {number}   [opts.freshnessMin=15]     Registry-entry freshness threshold in minutes.
  * @param {number}   [opts.now]                 ms-since-epoch (test seam for heartbeat freshness).
- * @returns {Promise<Array<{worktreePath:string,sessionId:string,mode:string,startedAt:string,pid:number,host:string,branch:string}>>}
+ * @returns {Promise<Array<{worktreePath:string,sessionId:string,mode:string,startedAt:string,pid:number,host:string,host_id:string,branch:string,registryOnly?:boolean,lockSuperseded?:boolean,lockOwnerId?:string|null}>>}
+ *   The last three fields appear ONLY on registry-sourced sessions (GH#67
+ *   annotation — see `sessionFromRegistryEntry`); lock-sourced sessions omit
+ *   them entirely.
  */
 export async function discoverActiveSessions(repoRoot, opts = {}) {
   const listWorktreesFn = opts.listWorktreesImpl ?? listWorktrees;
@@ -222,10 +276,20 @@ export async function discoverActiveSessions(repoRoot, opts = {}) {
   try {
     const allEntries = await registryReaderFn();
     const myRepoHash = repoPathHash(repoRoot);
+    // GH#67: who (if anyone) holds a LIVE lock at this repoRoot right now.
+    // Read once, outside the map — it is a property of the repo, not of an
+    // entry. A stale lock proves nothing, so it yields null.
+    const localLock = readLock({ repoRoot });
+    const lockOwnerId = (
+      localLock
+      && isLockLive(localLock, nowMs)
+      && typeof localLock.session_id === 'string'
+      && localLock.session_id
+    ) ? localLock.session_id : null;
     registrySessions = allEntries
       .filter((e) => e && e.repo_path_hash === myRepoHash)
       .filter((e) => isRegistryEntryFresh(e, { freshnessMin, now: nowMs }))
-      .map((e) => sessionFromRegistryEntry(e, repoRoot));
+      .map((e) => sessionFromRegistryEntry(e, repoRoot, { lockOwnerId }));
   } catch {
     // Registry read failure → keep going with lock-only results.
     registrySessions = [];

package/scripts/lib/session-end/phase-skip.mjs

@@ -37,6 +37,10 @@
  *   ('config-gate' | 'proposals.jsonl' | 'sweep-dry-run' | 'auto-dream-signal' |
  *    'skill-invocations.jsonl' | 'auto-dialectic-signal' | 'reconcile-dry-run' |
  *    'learnings.jsonl' | 'probe-error').
+ * @property {string[]} [targets] - 3.6.8 only, RUN decisions only: the effective
+ *   reconcile write-targets (issue #1099). Additive — absent on every other phase.
+ * @property {string|null} [baselineRoot] - 3.6.8 only, RUN decisions only: the
+ *   resolved projects-baseline root, or null when `baseline` is not in effect.
  *
  * @typedef {Object} TailPlan
  * @property {PhaseDecision[]} plan
@@ -51,7 +55,7 @@ import { sweepExpiredLearnings } from '../learnings/expiry-sweep.mjs';
 import { shouldDispatchAutoDream } from '../auto-dream.mjs';
 import { shouldDispatchAutoDialectic } from '../auto-dialectic.mjs';
 import { readSkillInvocations } from '../skill-invocations-schema.mjs';
-import { runReconcile } from '../reconcile/engine.mjs';
+import { runReconcileFromPhaseSkip, resolveEffectiveTargets } from '../reconcile/engine.mjs';
 import { resolveMemoryDir } from '../memory-paths.mjs';
 
 // ---------------------------------------------------------------------------
@@ -178,7 +182,9 @@ async function decideAutoDream({ repoRoot, cfg, platform, memoryDir }) {
     if (!isClaudePlatform(platform)) {
       return mkSkip(phase, 'non-Claude-Code platform (memory dir unavailable)', 'config-gate');
     }
-    const dir = memoryDir ?? resolveMemoryDir();
+    // #1071: same root as the `repoRoot` handed to shouldDispatchAutoDream below —
+    // a cwd-derived memory dir made the two halves of this decision disagree.
+    const dir = memoryDir ?? resolveMemoryDir(repoRoot);
     const dec = await shouldDispatchAutoDream({
       repoRoot,
       memoryDir: dir,
@@ -259,6 +265,14 @@ async function decideAutoDialectic({ repoRoot, cfg }) {
  * with `dryRun: true` (SKIPs the candidate-sidecar merge — no write) and the
  * operator confidence-floor delivery gate. 0 proposals above floor → skip.
  * runReconcile never throws; an engine `error` is treated fail-open (run).
+ *
+ * Target resolution (#1099) happens HERE — the layer where config → host-path
+ * resolution already lives — and deliberately only on the RUN branch: a WARN
+ * about an unusable baseline root in a session that had nothing to propose
+ * anyway would fire on almost every session and teach the operator to ignore it
+ * (`.claude/rules/host-resources.md` § HR-101). A `baseline` target that cannot
+ * be written is dropped BEFORE the coordinator surfaces the approval AUQ, so the
+ * operator is never asked to approve a write to a destination that cannot exist.
  */
 async function decideReconcile({ repoRoot, cfg }) {
   const phase = '3.6.8';
@@ -271,7 +285,7 @@ async function decideReconcile({ repoRoot, cfg }) {
     if (!existsSync(learningsPath)) {
       return mkSkip(phase, 'learnings.jsonl absent', 'learnings.jsonl');
     }
-    const { proposals, summary, error } = await runReconcile({
+    const { proposals, summary, error } = await runReconcileFromPhaseSkip({
       repoRoot,
       ruleExpiryDays: cfg?.reconcile?.['rule-expiry-days'] ?? undefined,
       minRuleDays: cfg?.reconcile?.['min-rule-days'] ?? undefined,
@@ -292,7 +306,26 @@ async function decideReconcile({ repoRoot, cfg }) {
         'reconcile-dry-run',
       );
     }
-    return mkRun(phase, `${surfaced.length} proposal(s) above confidence floor`, 'reconcile-dry-run');
+    const { targets, baselineRoot } = resolveEffectiveTargets({
+      targets: cfg?.reconcile?.targets,
+      baselineRoot: cfg?.['plan-baseline-path'],
+    });
+    if (targets.length === 0) {
+      return mkSkip(
+        phase,
+        `${surfaced.length} proposal(s) above floor but no writable target remains`,
+        'config-gate',
+      );
+    }
+    return {
+      ...mkRun(
+        phase,
+        `${surfaced.length} proposal(s) above confidence floor → targets: ${targets.join(', ')}`,
+        'reconcile-dry-run',
+      ),
+      targets,
+      baselineRoot,
+    };
   } catch (err) {
     return mkProbeError(phase, err);
   }
@@ -332,7 +365,7 @@ export function buildSkippedReport(plan) {
  * @param {object}  args.config     Parsed Session Config object (from parse-config.mjs).
  * @param {string|null} [args.sessionId] Current session id (for the 3.6.6 judged-set filter).
  * @param {string}  [args.platform] Platform id ('claude' | 'codex' | 'cursor' | …).
- * @param {string}  [args.memoryDir] Optional Auto-Dream memory dir override (default resolveMemoryDir()).
+ * @param {string}  [args.memoryDir] Optional Auto-Dream memory dir override (default resolveMemoryDir(repoRoot)).
  * @returns {Promise<TailPlan>}
  */
 export async function planTailPhases({ repoRoot, config, sessionId, platform, memoryDir } = {}) {

package/scripts/lib/session-end/worktree-cleanup.mjs

@@ -2,9 +2,12 @@
  * worktree-cleanup.mjs — Phase 4a Auto-Promoted Worktree Cleanup helpers (#575 P3.2).
  *
  * Public API:
- *   - detectAutoPromotedWorktree(repoRoot, sessionId, opts): { wtPath, sessionId, branch } | null
+ *   - detectAutoPromotedWorktree(repoRoot, sessionId, opts): { wtPath, sessionId, branch, source } | null
  *   - isWorktreeClean(wtPath, opts): boolean
  *     (opts.execFileFn — injectable execFileSync seam for tests; #577 HARDEN-001)
+ *   - PROMOTION_MARKER_RELPATH — repo-relative path of the promotion marker
+ *     written by `enterWorktree()` (SSOT for the file location; the WRITER
+ *     imports this constant from here, so writer and reader can never drift).
  *
  * Closes #575 — Epic #568 Phase 3.2 (Parallel-Aware Sessions Auto-Promoted Worktree Cleanup)
  * PRD: "Parallel-aware sessions" (#568; archived in the private Meta-Vault) §3 P3 Gherkin rows 2-3
@@ -21,27 +24,162 @@
  * kept divergent on purpose — unifying them would break the sync/async boundary.
  */
 import path from 'node:path';
+import { readFileSync } from 'node:fs';
 import { execFileSync } from 'node:child_process';
 import { parseSessionId } from '../session-id.mjs';
 
+/**
+ * Repo-relative location of the promotion marker `enterWorktree()` drops into
+ * every worktree it creates. Deliberately inside `.orchestrator/` (the session
+ * state dir) and deliberately WITHOUT any absolute path in its payload — the
+ * source checkout is recorded as `repoPathHash()` so the file can be committed
+ * or shipped without leaking the operator's filesystem layout.
+ *
+ * @type {string}
+ */
+export const PROMOTION_MARKER_RELPATH = path.join('.orchestrator', 'promoted-from.json');
+
+/**
+ * Read + shape-validate the promotion marker of a candidate worktree.
+ *
+ * Never throws: a missing file, a directory, unreadable permissions, invalid
+ * JSON, or a payload of the wrong shape all mean "no marker" (→ legacy path).
+ *
+ * @param {string} repoRoot
+ * @returns {{branch: string, source_session_id: string} & Record<string, unknown> | null}
+ */
+function readPromotionMarker(repoRoot) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(path.join(repoRoot, PROMOTION_MARKER_RELPATH), 'utf8'));
+  } catch {
+    return null; // absent / unreadable / corrupt JSON — fall back to legacy detection
+  }
+  if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) return null;
+  if (typeof parsed.branch !== 'string' || parsed.branch.length === 0) return null;
+  if (typeof parsed.source_session_id !== 'string' || parsed.source_session_id.length === 0) {
+    return null;
+  }
+  return parsed;
+}
+
+/**
+ * The marker path as git reports it in `status --porcelain` — always
+ * forward-slashed, regardless of the host separator.
+ * @type {string}
+ */
+const PROMOTION_MARKER_GIT_PATH = PROMOTION_MARKER_RELPATH.split(path.sep).join('/');
+
+/**
+ * True for the ONE porcelain line the promotion marker itself produces:
+ * `?? .orchestrator/promoted-from.json`.
+ *
+ * Why this exists: in THIS repo `.gitignore` already lists
+ * `.orchestrator/promoted-from.json` explicitly (`git check-ignore
+ * .orchestrator/promoted-from.json` exits 0), so the marker never reaches
+ * `git status --porcelain` here at all — this exemption is redundant
+ * belt-and-braces for the repo that ships it. It earns its keep in CONSUMER
+ * repos: `.orchestrator/` is commonly only PARTLY gitignored there
+ * (`.orchestrator/metrics/*.jsonl`, `session.lock`, … but not the bare
+ * directory, and not necessarily this file), and on a worktree whose branch
+ * predates that ignore line being added, the marker would show up as an
+ * untracked file and make every promoted worktree read "dirty" — turning the
+ * Phase 4a clean path (auto-remove) into a permanent operator AUQ. Repos that
+ * gitignore `.orchestrator/` wholesale never see the line at all. A third shape exists —
+ * the directory untracked AND un-ignored, where git collapses everything into
+ * one `?? .orchestrator/` line — and is deliberately NOT matched here:
+ * discounting a whole directory could hide operator work, and such a worktree
+ * is already dirty from the session's own `session.lock` / `STATE.md` writes
+ * regardless of this marker.
+ *
+ * Deliberately narrow: ONLY the untracked (`??`) status of exactly this path is
+ * ignored. A modified, staged, renamed or conflicted marker still counts as
+ * dirty, and no other file under `.orchestrator/` is affected — this is our own
+ * bookkeeping artefact, not operator work (PSA-003: we created it, so it is
+ * ours to discount).
+ *
+ * @param {string} line - One `git status --porcelain` line.
+ * @returns {boolean}
+ */
+function isUntrackedPromotionMarker(line) {
+  if (!line.startsWith('?? ')) return false;
+  const filePath = line.slice(3).trim().replace(/^"(.*)"$/, '$1');
+  return filePath === PROMOTION_MARKER_GIT_PATH;
+}
+
+/**
+ * Current branch of a worktree, or `null` when it cannot be determined
+ * (git error, or a detached HEAD — `git branch --show-current` prints nothing).
+ *
+ * @param {Function} execFileFn
+ * @param {string} repoRoot
+ * @returns {string|null}
+ */
+function currentBranchOf(execFileFn, repoRoot) {
+  try {
+    const out = execFileFn('git', ['-C', repoRoot, 'branch', '--show-current'], {
+      encoding: 'utf8',
+    });
+    const branch = String(out ?? '').trim();
+    return branch.length > 0 ? branch : null;
+  } catch {
+    return null;
+  }
+}
+
 /**
  * Detect whether the given repoRoot is an auto-promoted sibling worktree
  * created by `enterWorktree()` during the Phase 0.5 PROMOTION_OFFER path.
  *
- * Auto-promoted layout: <basePath>/<repo-name>-<sessionId>/
+ * Two keys, tried in this order:
+ *
+ *  1. **Marker (primary).** `<repoRoot>/.orchestrator/promoted-from.json`,
+ *     written by `enterWorktree()` at creation time. Accepted when the file
+ *     parses, carries `branch` + `source_session_id`, and the worktree's
+ *     current branch either MATCHES the recorded one or cannot be read at all.
+ *     This is the only key that survives the #1069 process boundary: since
+ *     #1069 the session that RUNS in the promoted worktree is a NEW session
+ *     with its OWN id, and since #1067 the worktree sits on `so/<sourceId>` —
+ *     so the current session's id appears in neither the directory name nor
+ *     the branch, and key 2 below can never match. Recording the fact at
+ *     creation time is what makes it re-derivable later.
+ *  2. **Basename (legacy fallback).** `<basePath>/<main-repo-name>-<sessionId>/`
+ *     against the CURRENT session id — still correct for worktrees created
+ *     before the marker existed, and for the same-session case.
  *
  * Returns:
- *   { wtPath, sessionId, branch } on match
+ *   { wtPath, sessionId, branch, source: 'marker'|'basename' } on match
  *   null on non-match (UUID session, non-promoted path, or git error)
  *
  * @param {string} repoRoot - Absolute path to the candidate worktree
  * @param {string} sessionId - Session ID (semantic or UUID)
- * @returns {{wtPath: string, sessionId: string, branch: string} | null}
+ * @returns {{wtPath: string, sessionId: string, branch: string, source: 'marker'|'basename'} | null}
  */
 export function detectAutoPromotedWorktree(repoRoot, sessionId, opts = {}) {
   // #577 HARDEN-001: execFileSync + args ARRAY (no shell) is structurally
   // injection-proof — repoRoot can never be interpreted as shell metacharacters.
   const execFileFn = opts.execFileFn ?? execFileSync;
+
+  // --- Key 1: the marker written at creation time (session-id independent) ---
+  const marker = readPromotionMarker(repoRoot);
+  if (marker) {
+    const current = currentBranchOf(execFileFn, repoRoot);
+    // `current === null` (git unavailable / detached HEAD) is accepted: the
+    // marker is written by exactly one code path, and the destructive step in
+    // Phase 4a is gated separately by `isWorktreeClean()`, which fails CLOSED
+    // on any git error. So an unverifiable branch can only ever route the
+    // operator into the AUQ, never into an automatic removal.
+    if (current === null || current === marker.branch) {
+      return {
+        wtPath: repoRoot,
+        sessionId: marker.source_session_id,
+        branch: marker.branch,
+        source: 'marker',
+      };
+    }
+  }
+
+  // --- Key 2: legacy basename match against the CURRENT session id ---
   const parsed = parseSessionId(sessionId);
   if (!parsed || parsed.format !== 'semantic') return null; // UUID-format sessions are never auto-promoted
 
@@ -72,7 +210,7 @@ export function detectAutoPromotedWorktree(repoRoot, sessionId, opts = {}) {
   const isPromotedPath = path.basename(repoRoot) === expectedBasename;
 
   if (isPromotedPath) {
-    return { wtPath: repoRoot, sessionId, branch: parsed.branch };
+    return { wtPath: repoRoot, sessionId, branch: parsed.branch, source: 'basename' };
   }
   return null;
 }
@@ -82,7 +220,9 @@ export function detectAutoPromotedWorktree(repoRoot, sessionId, opts = {}) {
  *
  * A worktree is clean iff ALL three conditions hold:
  *   1. No uncommitted changes (`git status --porcelain` is empty)
- *   2. No untracked files (implicit in #1 — porcelain includes `??` entries)
+ *   2. No untracked files (implicit in #1 — porcelain includes `??` entries),
+ *      with ONE exception: the untracked promotion marker this module's own
+ *      writer drops into the worktree (see isUntrackedPromotionMarker)
  *   3. No unpushed commits (`git status --short --branch` lacks `ahead`)
  *
  * On any git error, returns `false` (safer per PSA-003 — conservative default
@@ -98,7 +238,14 @@ export function isWorktreeClean(wtPath, opts = {}) {
     const status = execFileFn('git', ['-C', wtPath, 'status', '--porcelain'], {
       encoding: 'utf8',
     });
-    if (status.trim().length > 0) return false; // dirty (modified, untracked, or staged)
+    const significant = String(status ?? '')
+      .split('\n')
+      .map((l) => l.trimEnd())
+      .filter((l) => l.length > 0)
+      // Our own promotion marker is not operator work — see
+      // isUntrackedPromotionMarker() for why it must not count as dirty.
+      .filter((l) => !isUntrackedPromotionMarker(l));
+    if (significant.length > 0) return false; // dirty (modified, untracked, or staged)
 
     const branchStatus = execFileFn('git', ['-C', wtPath, 'status', '--short', '--branch'], {
       encoding: 'utf8',

package/scripts/lib/session-id.mjs

@@ -6,7 +6,7 @@
  *   - parseSessionId(id): { format: 'semantic'|'uuid', ...fields, raw } | null
  *   - DEFAULT_SESSION_ID_SOURCES — the default `sources` array (see below)
  *   - SEMANTIC_ID_RE — source-of-truth regex for semantic session IDs
- *   - UUID_V4_RE     — regex for UUID-v4 format session IDs
+ *   - UUID_RE        — regex for RFC 9562 UUID session IDs (any version 1–8)
  *
  * Closes #572 — Epic #568 Phase 2.1 (Parallel-Aware Sessions Semantic ID)
  * Closes #585 — Epic #583 W2-I2 (history-aware n-increment) per audit
@@ -67,14 +67,25 @@ import { parseStateMd } from './state-md/yaml-parser.mjs';
 export const SEMANTIC_ID_RE = /^([a-z0-9._/-]+)-(\d{4}-\d{2}-\d{2})-([a-z-]+)-(\d+)$/;
 
 /**
- * Regex for UUID-v4 session IDs.
+ * Regex for RFC 9562 UUID session IDs — ANY version 1–8, variant `10xx`.
  *
- * Matches: 8-4-4-4-12 hex digits, version nibble = '4', variant nibble in {8,9,a,b}.
- * Case-insensitive to accept both uppercase and lowercase hex.
+ * Matches: 8-4-4-4-12 hex digits, version nibble in [1-8], variant nibble in
+ * {8,9,a,b}. Case-insensitive to accept both uppercase and lowercase hex.
+ *
+ * Why the version nibble is a RANGE and not the literal `4` (Kanevry#66 / #1091):
+ * Claude Code mints UUIDv4 session ids, but Codex CLI mints UUIDv7. Pinning `4`
+ * made `parseSessionId()` return `null` for every Codex session, so
+ * `hooks/on-session-start.mjs` fell through to a freshly generated
+ * `randomUUID()` and every later hook in that session missed the lock.
+ *
+ * The structure stays strict on purpose: the dash/length layout and the
+ * variant nibble are what discriminate a real UUID from a 36-char lookalike,
+ * so only the version nibble is widened. Version `0` (nil UUID) and `9`..`f`
+ * (unassigned / max UUID) remain rejected — RFC 9562 defines 1–8.
  *
  * @type {RegExp}
  */
-export const UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+export const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
 
 // ---------------------------------------------------------------------------
 // Internal helpers
@@ -344,8 +355,12 @@ export const DEFAULT_SESSION_ID_SOURCES = Object.freeze([
  *   1. Semantic: `<branch>-<YYYY-MM-DD>-<mode>-<n>`
  *      Returns `{ format: 'semantic', branch, date, mode, n, raw }`.
  *
- *   2. UUID-v4: `xxxxxxxx-xxxx-4xxx-[89ab]xxx-xxxxxxxxxxxx`
- *      Returns `{ format: 'uuid', uuid, raw }`.
+ *   2. RFC 9562 UUID, any version 1–8, variant `10xx`:
+ *      `xxxxxxxx-xxxx-[1-8]xxx-[89ab]xxx-xxxxxxxxxxxx`
+ *      Returns `{ format: 'uuid', uuid, version, raw }`, where `version` is the
+ *      version nibble as an integer (4 for Claude Code's v4 ids, 7 for Codex
+ *      CLI's v7 ids). Callers that only branch on `format` are unaffected —
+ *      `version` is additive (Kanevry#66 / #1091).
  *
  * Returns `null` for any input that is not a non-empty string or does not
  * match either known format. Never throws.
@@ -356,7 +371,7 @@ export const DEFAULT_SESSION_ID_SOURCES = Object.freeze([
  *
  * @param {unknown} id - The session ID to parse.
  * @returns {{ format: 'semantic', branch: string, date: string, mode: string, n: number, raw: string }
- *           | { format: 'uuid', uuid: string, raw: string }
+ *           | { format: 'uuid', uuid: string, version: number, raw: string }
  *           | null}
  */
 export function parseSessionId(id) {
@@ -375,9 +390,10 @@ export function parseSessionId(id) {
     };
   }
 
-  // Try UUID-v4.
-  if (UUID_V4_RE.test(id)) {
-    return { format: 'uuid', uuid: id, raw: id };
+  // Try RFC 9562 UUID (any version 1–8). Index 14 is the version nibble, and
+  // UUID_RE has already constrained it to [1-8], so Number() cannot be NaN.
+  if (UUID_RE.test(id)) {
+    return { format: 'uuid', uuid: id, version: Number(id[14]), raw: id };
   }
 
   return null;
@@ -418,9 +434,9 @@ export function parseSessionId(id) {
  *   cannot assign the same n. The #952 collision was NOT a concurrency defect —
  *   the lock held; the candidate set was incomplete.
  *
- * UUID-v4 entries (in any source) are silently dropped (parseSessionId returns
- * format:'uuid' which the filter excludes). Malformed semantic-looking IDs are
- * also dropped (SEMANTIC_ID_RE rejects them).
+ * UUID entries of ANY version (in any source) are silently dropped
+ * (parseSessionId returns format:'uuid' which the filter excludes). Malformed
+ * semantic-looking IDs are also dropped (SEMANTIC_ID_RE rejects them).
  *
  * @param {object} opts
  * @param {string} opts.branch - Current git branch (e.g. "main", "feature/foo").