session-orchestrator 4.0.1 → 4.2.0

package/scripts/lib/session-close-backfill.mjs

@@ -25,7 +25,8 @@
  * `'abandoned'` — the session itself claims to have finished normally).
  *
  * ── ID BRIDGE ────────────────────────────────────────────────────────────────
- *   sessions.jsonl records are keyed by SEMANTIC ids (`main-2026-05-27-session-1`).
+ *   Legacy sessions.jsonl records are keyed by semantic ids; native records
+ *   use the harness UUID with a separate `semantic_session_id` label.
  *   events.jsonl carries the harness UUID on `session.started` / `stop` / `ended`.
  *   The bridge is the `orchestrator.session.lock.acquired` event, which is the
  *   only record carrying BOTH `session_id` (UUID) and `semantic_session_id`.
@@ -62,6 +63,12 @@ import { validateSession as defaultValidateSession } from './session-schema/vali
 import { serializeSessionLineChecked as defaultSerialize } from './session-schema.mjs';
 import { resolveStateMdPath as defaultResolveStateMdPath } from './state-md/frontmatter-mutators.mjs';
 import { parseStateMd as defaultParseStateMd } from './state-md/yaml-parser.mjs';
+import { canonicalizeSessions } from './sessions-canonical.mjs';
+// Leaf constants module (no imports of its own) and ALREADY in the hook import
+// set via session-schema/validator.mjs — importing it here adds no new file to
+// the SessionStart/SessionEnd hook graph. The profile enum must not be
+// re-literalled: `VALID_SESSION_PROFILES` is its SSOT (GitLab #1252).
+import { VALID_SESSION_PROFILES } from './session-schema/constants.mjs';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -84,6 +91,16 @@ const UNMEASURED_SESSION_TYPE = 'unknown';
 
 const EVENT_STARTED = 'orchestrator.session.started';
 const EVENT_LOCK_ACQUIRED = 'orchestrator.session.lock.acquired';
+/**
+ * `orchestrator.session.shape_resolved` (`scripts/lib/session-shape.mjs`) — the
+ * ONLY event emitted AFTER the operator picked a mode, so it is the only
+ * measurement of what this session actually was. `lock.acquired.mode` fires at
+ * SessionStart, BEFORE `/session <type>` is typed, which is why nearly every
+ * abandoned stub carried `_session_type_inferred: true`; and no other event
+ * carries `session_profile` at all, so an abandoned ultradeep run was
+ * indistinguishable from an abandoned deep one.
+ */
+const EVENT_SHAPE_RESOLVED = 'orchestrator.session.shape_resolved';
 // Both names for one generation (GitLab #1234): `hooks/on-stop.mjs` now emits
 // `orchestrator.turn.stopped` as the canonical name and keeps the legacy
 // `orchestrator.session.stopped` (with `deprecated: true`) beside it until
@@ -178,7 +195,8 @@ function canonicalIso(value, fallbackMs) {
  */
 function collectSessionEvents(events, { sessionId, semanticSessionId }) {
   const uuids = new Set();
-  if (isUuid(sessionId)) uuids.add(sessionId);
+  const nativeId = isUuid(sessionId) ? sessionId : null;
+  if (nativeId) uuids.add(nativeId);
 
   let mode = null;
   let semanticFromLock = null;
@@ -190,25 +208,72 @@ function collectSessionEvents(events, { sessionId, semanticSessionId }) {
   // SessionEnd hook had already recorded under its semantic id. Measured
   // 2026-09-02 @ c3ab480: 8 such duplicate pairs in sessions.jsonl.
   let semanticFromEvents = null;
+  // Plan-time shape measurement (see EVENT_SHAPE_RESOLVED). Latest wins — a
+  // session may re-resolve its shape, and the last resolution is the one it ran.
+  // "Latest" is only decidable for a record that CARRIES a parseable timestamp:
+  // an undated one has no place in the order, so it may never displace a dated
+  // reading (the earlier `Number.isNaN(ts) => ordered` inverted exactly that and
+  // let an undated record win over a later, well-dated one).
+  let shapeSessionType = null;
+  let shapeSessionProfile = null;
+  let shapeTs = null;
+  // True while the readings above come from an UNDATED record — kept only for
+  // lack of a dated one, and surfaced so the caller can mark it low-confidence.
+  let shapeUndated = false;
 
   // First pass — bridge the UUID set + carry mode + semantic id. lock.acquired
-  // is the original bridge; session.ended is the #1167 addition.
+  // is the original bridge; session.ended is the #1167 addition;
+  // shape_resolved is the plan-time type/profile measurement.
   for (const ev of events) {
     const isLock = ev.event === EVENT_LOCK_ACQUIRED;
     const isEnded = ev.event === EVENT_ENDED && typeof ev.semantic_session_id === 'string';
-    if (!isLock && !isEnded) continue;
-    const matchesUuid = isUuid(sessionId) && ev.session_id === sessionId;
-    const matchesSemantic =
+    const isShape = ev.event === EVENT_SHAPE_RESOLVED;
+    if (!isLock && !isEnded && !isShape) continue;
+    const matchesUuid = nativeId && ev.session_id === nativeId;
+    // A label can be reused. Once a native UUID is known, a same-label event
+    // from another UUID must not expand the session whose work we recover.
+    const matchesSemantic = !nativeId && (
       (semanticSessionId && ev.semantic_session_id === semanticSessionId) ||
-      (!isUuid(sessionId) && sessionId && ev.semantic_session_id === sessionId);
+      (sessionId && ev.semantic_session_id === sessionId)
+    );
     if (!matchesUuid && !matchesSemantic) continue;
     if (typeof ev.session_id === 'string') uuids.add(ev.session_id);
     if (isLock) {
       if (typeof ev.mode === 'string') mode = ev.mode;
       if (typeof ev.semantic_session_id === 'string') semanticFromLock = ev.semantic_session_id;
-    } else {
+    } else if (isEnded) {
       semanticFromEvents = ev.semantic_session_id;
     }
+    if (isShape) {
+      const ts = typeof ev.timestamp === 'string' ? Date.parse(ev.timestamp) : NaN;
+      if (!Number.isNaN(ts)) {
+        // Dated record: ordinary latest-wins.
+        if (shapeTs === null || ts >= shapeTs) {
+          if (shapeUndated) {
+            // A dated record outranks an undated one unconditionally. The
+            // undated readings were never orderable, so they are DISCARDED
+            // rather than merged — otherwise a profile read off an undated
+            // record would survive into a dated win it never belonged to.
+            shapeSessionType = null;
+            shapeSessionProfile = null;
+            shapeUndated = false;
+          }
+          shapeTs = shapeTs === null ? ts : Math.max(shapeTs, ts);
+          if (typeof ev.session_type === 'string') shapeSessionType = ev.session_type;
+          // Absent is not empty: the emitter OMITS the key when there is no
+          // profile, so only a present string may overwrite a previous reading.
+          if (typeof ev.session_profile === 'string') shapeSessionProfile = ev.session_profile;
+        }
+      } else if (shapeTs === null && !shapeUndated) {
+        // Undated record: usable only while NO dated record has been seen, and
+        // never as a tie-breaker between two of them.
+        const hasType = typeof ev.session_type === 'string';
+        const hasProfile = typeof ev.session_profile === 'string';
+        if (hasType) shapeSessionType = ev.session_type;
+        if (hasProfile) shapeSessionProfile = ev.session_profile;
+        if (hasType || hasProfile) shapeUndated = true;
+      }
+    }
   }
 
   // Second pass — started + terminal timestamps from every matched UUID.
@@ -247,6 +312,9 @@ function collectSessionEvents(events, { sessionId, semanticSessionId }) {
   return {
     uuids,
     mode,
+    shapeSessionType,
+    shapeSessionProfile,
+    shapeUndated,
     semanticFromLock,
     semanticFromEvents,
     startedAt,
@@ -336,13 +404,37 @@ function synthesizeRecord({ recordId, synthetic, gathered, nowMs, status = 'aban
   // Guard the same monotonic invariant as before: never earlier than started_at.
   const completedIso = new Date(Math.max(startedMs, completedMs)).toISOString();
 
+  // Precedence: the plan-time shape beats the lock's SessionStart `mode`.
+  // `lock.acquired` fires BEFORE the operator types `/session <type>`, so its
+  // mode is at best a carry-over from the previous session; `shape_resolved` is
+  // emitted the moment the confirmed mode became an execution plan, i.e. it is
+  // the only MEASUREMENT of what this session was. Any session that reached
+  // plan time is therefore no longer `_session_type_inferred`.
+  // An unknown value in either source is IGNORED, never written — the record
+  // then stays `unknown` + inferred rather than carrying an unvalidatable type.
   let sessionType = UNMEASURED_SESSION_TYPE;
   let inferred = true;
-  if (gathered.mode && MEASURED_SESSION_MODES.has(gathered.mode)) {
+  if (gathered.shapeSessionType && MEASURED_SESSION_MODES.has(gathered.shapeSessionType)) {
+    sessionType = gathered.shapeSessionType;
+    // A shape record with a missing/unparseable timestamp is taken only for
+    // lack of a dated one, and it cannot be proven to be the LAST resolution —
+    // so the type is used but stays flagged `_session_type_inferred: true`.
+    inferred = gathered.shapeUndated === true;
+  } else if (gathered.mode && MEASURED_SESSION_MODES.has(gathered.mode)) {
     sessionType = gathered.mode;
     inferred = false;
   }
 
+  // `session_profile` — WRITTEN ONLY WHEN MEASURED. Absent is not empty: a
+  // `null`/`''` on the record would read as "measured, no profile", which is
+  // exactly the honesty defect the enum-plus-omission contract exists to avoid
+  // (VALID_SESSION_PROFILES, session-schema/constants.mjs).
+  const sessionProfile =
+    typeof gathered.shapeSessionProfile === 'string'
+      && VALID_SESSION_PROFILES.includes(gathered.shapeSessionProfile)
+      ? gathered.shapeSessionProfile
+      : null;
+
   const startedFound = typeof gathered.startedAt === 'string';
   const branchFound = typeof gathered.branch === 'string' && gathered.branch.length > 0;
 
@@ -375,6 +467,7 @@ function synthesizeRecord({ recordId, synthetic, gathered, nowMs, status = 'aban
     _backfill_incomplete_fields: incomplete,
   };
   if (branchFound) record.branch = gathered.branch;
+  if (sessionProfile) record.session_profile = sessionProfile;
   if (inferred) {
     record._session_type_inferred = true;
     // GitLab #1234 — BACKFILLER HONESTY, half landed 2026-09-06.
@@ -452,6 +545,48 @@ function isBackfillStub(record) {
   return BACKFILL_STUB_STATUSES.has(record.status);
 }
 
+/**
+ * Find the newest ledger record for one physical session. Shared by the close
+ * precheck and backfill dedupe; no file I/O or mutation.
+ *
+ * Native identity wins over the attribution label. A conflicting native UUID
+ * vetoes a label match. Legacy records without a native join remain readable;
+ * when both start times are known they must name the same instant.
+ *
+ * @param {object[]} records parsed JSONL records, in append order
+ * @param {{sessionId?: string|null, semanticSessionId?: string|null, startedAt?: string|null}} ids
+ * @returns {object|null} existing record, or null when no identity matches
+ */
+export function findRecordedSession(records, { sessionId = null, semanticSessionId = null, startedAt = null } = {}) {
+  // Identity strength cannot resurrect an overwritten/superseded stub. Use
+  // the canonical reader, while retaining append order across surviving keys.
+  const canonical = new Set(canonicalizeSessions(records));
+  const nativeId = isUuid(sessionId) ? sessionId : isUuid(semanticSessionId) ? semanticSessionId : null;
+  const label = semanticSessionId || sessionId;
+  const startMs = typeof startedAt === 'string' ? Date.parse(startedAt) : NaN;
+  let legacyMatch = null;
+  for (let i = records.length - 1; i >= 0; i--) {
+    const record = records[i];
+    if (!canonical.has(record)) continue;
+    if (!record || typeof record !== 'object' || Array.isArray(record)
+      || typeof record.session_id !== 'string' || !record.session_id) continue;
+    const nativeKeys = [record.session_id, record.raw_session_id].filter(isUuid);
+    if (nativeId && nativeKeys.length > 0) {
+      if (nativeKeys.every((id) => id === nativeId)) return record;
+      continue;
+    }
+    if (!label || (record.session_id !== label && record.semantic_session_id !== label)) continue;
+    // A backfill's fallback timestamp is explicitly unmeasured; treating it as
+    // a conflicting start would defeat idempotence on the very next close.
+    const incompleteStart = Array.isArray(record._backfill_incomplete_fields)
+      && record._backfill_incomplete_fields.includes('started_at');
+    const recordStart = !incompleteStart && typeof record.started_at === 'string' ? Date.parse(record.started_at) : NaN;
+    if (Number.isFinite(startMs) && Number.isFinite(recordStart) && startMs !== recordStart) continue;
+    legacyMatch ??= record;
+  }
+  return legacyMatch;
+}
+
 /**
  * Classify what sessions.jsonl already holds for this identity (#1068 AC3/AC4).
  *
@@ -469,23 +604,12 @@ function isBackfillStub(record) {
  *
  * @param {Function} readFileSync
  * @param {string} sessionsPath
- * @param {{recordId: string, sessionId: string|null}} ids
+ * @param {{recordId: string, sessionId: string|null, semanticSessionId?: string|null, startedAt?: string|null}} ids
  */
-function classifyExisting(readFileSync, sessionsPath, { recordId, sessionId }) {
+function classifyExisting(readFileSync, sessionsPath, { recordId, sessionId, semanticSessionId = recordId, startedAt = null }) {
   const sessionRecords = readJsonlSafe(readFileSync, sessionsPath);
-  // Both keys count: the semantic record id, and — defensively — a prior record
-  // keyed directly by the UUID.
-  const uuidKey = isUuid(sessionId) ? sessionId : null;
-  const byId = (id) =>
-    id === null ? [] : sessionRecords.filter((r) => r && r.session_id === id);
-  // Key preference is UNCHANGED from the pre-#1068 dedupe: the semantic
-  // recordId wins whenever any record carries it, and the UUID key is only the
-  // defensive fallback.
-  const semanticMatches = byId(recordId);
-  const matches = semanticMatches.length > 0 ? semanticMatches : byId(uuidKey);
-  if (matches.length === 0) return { kind: 'absent' };
-
-  const newest = matches[matches.length - 1];
+  const newest = findRecordedSession(sessionRecords, { sessionId, semanticSessionId, startedAt });
+  if (!newest) return { kind: 'absent' };
   if (isBackfillStub(newest)) {
     return { kind: 'stub', matchedId: newest.session_id, stubId: newest.session_id };
   }
@@ -650,6 +774,15 @@ export async function backfillAbandonedSession({
         if (dupe) return dupe;
       }
 
+      // Dedupe rejected any foreign native identity above. Do not now reuse
+      // that session's semantic key: canonical readers collapse by session_id.
+      // Keep the existing legacy key convention unless the key is occupied.
+      const semanticRecordId = recordId;
+      if (isUuid(sessionId) && recordId !== sessionId
+        && readJsonlSafe(readFileSync, sessionsPath).some((record) => record?.session_id === recordId)) {
+        recordId = sessionId;
+      }
+
       // -- Liveness guard — never overwrite a FOREIGN live lock, and never ----
       // record OUR OWN live lock as 'abandoned' (#863 defect 1). Before this
       // fix, the guard below only ever ran when `foreign` was true — the
@@ -720,6 +853,7 @@ export async function backfillAbandonedSession({
         nowMs,
         rawSessionId: isUuid(sessionId) ? sessionId : null,
       });
+      if (recordId !== semanticRecordId) record.semantic_session_id = semanticRecordId;
       let validated;
       try {
         validated = validateSession(record);
@@ -831,17 +965,12 @@ export async function backfillAbandonedSession({
  *   as "otherwise 0, flagged in `_backfill_incomplete_fields`" — the same
  *   contract the abandoned path already carries and the same reason it exists.
  *
- *   CONSTRAINT specific to this path: STATE.md's `session` field is already
- *   the SEMANTIC id, never the raw harness UUID — unlike
- *   `backfillAbandonedSession` (which usually receives the UUID directly from
- *   SessionEnd stdin), this function has no UUID to seed `collectSessionEvents`'s
- *   `uuids` set with. Events therefore only surface here when a
- *   `lock.acquired` breadcrumb bridges the UUID to this exact semantic id
- *   (`ev.semantic_session_id === recordId`) — the SAME bridge condition
- *   `backfillAbandonedSession`'s synthetic-id fallback exists to handle when
- *   ABSENT. Without that bridge, `gathered` stays empty and the record still
- *   validates (started_at/completed_at both fall back to `now`, flagged
- *   incomplete) — degraded but never blocked.
+ *   A native `session-id` in STATE.md seeds event correlation directly and
+ *   keys the new record; `session` is retained as `semantic_session_id`.
+ *   Legacy STATE.md without a native UUID keeps its semantic record key and
+ *   needs a lock.acquired/session.ended bridge to recover UUID-scoped events.
+ *   Without either identity route, timestamps fall back to `now` and are
+ *   flagged incomplete rather than fabricated from STATE.md body prose.
  *
  * Never throws. Returns one of:
  *   { action: 'backfilled', sessionId, record }              — written to disk
@@ -910,31 +1039,43 @@ export async function backfillCompletedFromStateMd({
         return { action: 'skipped-not-completed', status: stateStatus ?? null };
       }
 
-      const recordId = parsed.frontmatter?.session;
-      if (typeof recordId !== 'string' || recordId.length === 0) {
+      const semanticSessionId = parsed.frontmatter?.session;
+      if (typeof semanticSessionId !== 'string' || semanticSessionId.length === 0) {
         return { action: 'skipped-no-session-id' };
       }
+      const stateSessionId = parsed.frontmatter?.['session-id'];
+      const nativeId = isUuid(stateSessionId) ? stateSessionId : isUuid(semanticSessionId) ? semanticSessionId : null;
+      let recordId = nativeId ?? semanticSessionId;
 
       // -- Dedupe, or SUPERSEDE a backfill stub (#1068 AC3) ---------------------
       // This is the authoritative writer of the pair: STATE.md's own
       // `status: completed` is the session's truth claim about itself, and it
-      // arrives with an identity-complete key (the semantic id). When the only
+      // arrives with the native UUID or legacy semantic key. When the only
       // thing on file for that identity is a reconstructed `abandoned` stub,
       // the stub is a measurement this record refutes — so we append the fuller
       // record (carrying `supersedes: <stub id>`) instead of skipping. An
       // authoritative record already on file still short-circuits exactly as
       // before.
       const sessionsPath = path.join(repoRoot, ...SESSIONS_REL);
-      const existing = classifyExisting(readFileSync, sessionsPath, { recordId, sessionId: recordId });
+      const existing = classifyExisting(readFileSync, sessionsPath, {
+        recordId,
+        sessionId: nativeId,
+        semanticSessionId,
+        startedAt: parsed.frontmatter?.started_at,
+      });
       if (existing.kind === 'canonical') {
         return { action: 'skipped-already-recorded', sessionId: existing.matchedId };
       }
       const supersedes = existing.kind === 'stub' ? existing.stubId : null;
+      // Preserve a matched stub's key for its append-only replacement. Without
+      // event timestamps or a raw join on a legacy stub, a new UUID key would
+      // leave two canonical sessions: its supersedes proof is unattestable.
+      if (supersedes) recordId = supersedes;
 
       // -- Derive whatever is derivable from events.jsonl (never STATE.md body) -
       const eventsPath = path.join(repoRoot, ...EVENTS_REL);
       const events = readJsonlSafe(readFileSync, eventsPath);
-      const gathered = collectSessionEvents(events, { sessionId: null, semanticSessionId: recordId });
+      const gathered = collectSessionEvents(events, { sessionId: nativeId, semanticSessionId });
 
       // -- Synthesize + validate (round-trip gate) BEFORE any disk mutation ----
       const record = synthesizeRecord({
@@ -953,6 +1094,7 @@ export async function backfillCompletedFromStateMd({
         // same fail-quiet posture as `isUuid(sessionId) ? sessionId : null`.
         rawSessionId: gathered.uuids?.size === 1 ? [...gathered.uuids][0] : null,
       });
+      if (nativeId && semanticSessionId !== nativeId) record.semantic_session_id = semanticSessionId;
       let validated;
       try {
         validated = validateSession(record);

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

@@ -6,11 +6,23 @@
  * the close-out abort-attractor: six phases, each ~50 lines of coordinator prose,
  * that in the overwhelming majority of sessions do nothing (no proposals queued,
  * nothing expired, under cadence, judge off, reconcile off). This aggregator
- * computes — side-effect-free — WHICH of the six should actually run, so the
+ * computes — side-effect-free — WHICH of them should actually run, so the
  * coordinator loads only the detail procedure for the `run: true` phases and
  * emits a one-line `skippedReport` for the rest.
  *
- * Every one of the six phases already ships a mechanical fast-path in its own lib
+ * FOUR phases are still LIVE and decided here: 3.6.3, 3.6.4, 3.6.6, 3.6.8.
+ * TWO are RETIRED (2026-09-09) and always emit a `run: false` entry with
+ * `inputSource: 'retired'`: 3.6.5 Auto-Dream and 3.6.7 Auto-Dialectic. Both
+ * nudges are now computed once at SESSION-START by the `maintenance-due` probe
+ * (`scripts/lib/maintenance-due-banner.mjs`), which runs the same
+ * `shouldDispatchAutoDream` / `shouldDispatchAutoDialectic` signals and
+ * recommends `/session housekeeping`. Measured across three consumer repos the
+ * close-time nudges fired (`orchestrator.dialectic.nudge_decided`,
+ * `decided: true`, sessions_since 23/8/6) and were never acted on — computing
+ * them at every close was pure cost. The plan SHAPE is unchanged (still six
+ * entries, same ids, same order) so every reader keeps working.
+ *
+ * Each of the four live phases already ships a mechanical fast-path in its own lib
  * (a config kill-switch, an `existsSync` short-circuit, or a cadence/trigger
  * decision). This module WRAPS those existing signals — it never re-implements
  * their logic. Config gates run FIRST as the cheap short-circuit (no disk touch),
@@ -34,9 +46,10 @@
  * @property {boolean} run         - true → coordinator runs the detail procedure.
  * @property {string}  reason      - human-readable reason for the decision.
  * @property {string}  inputSource - which signal drove the decision
- *   ('config-gate' | 'proposals.jsonl' | 'sweep-dry-run' | 'auto-dream-signal' |
- *    'skill-invocations.jsonl' | 'auto-dialectic-signal' | 'reconcile-dry-run' |
- *    'learnings.jsonl' | 'probe-error').
+ *   ('config-gate' | 'proposals.jsonl' | 'sweep-dry-run' |
+ *    'skill-invocations.jsonl' | 'reconcile-dry-run' | 'learnings.jsonl' |
+ *    'retired' | 'probe-error'). `'retired'` is emitted only by the two
+ *    permanently-skipped phases 3.6.5 / 3.6.7 — no signal was consulted at all.
  * @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
@@ -52,11 +65,38 @@ import path from 'node:path';
 
 import { collectProposals } from '../memory-proposals/collector.mjs';
 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 { runReconcileFromPhaseSkip, resolveEffectiveTargets } from '../reconcile/engine.mjs';
-import { resolveMemoryDir } from '../memory-paths.mjs';
+
+// NOTE (2026-09-09): `shouldDispatchAutoDream` / `shouldDispatchAutoDialectic`
+// are deliberately NOT imported here any more — 3.6.5 and 3.6.7 are retired and
+// the two signals are computed once at session-start by the `maintenance-due`
+// probe. Re-adding either import is the regression this module's test suite
+// guards against.
+
+// ---------------------------------------------------------------------------
+// Shared path resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the learnings store + archive sidecar paths for a repo.
+ *
+ * Exported because `session-end/tail-runner.mjs` (the APPLY counterpart to the
+ * 3.6.4 dry-run decision below) must sweep exactly the pair this decision
+ * probed. Two hand-written `path.join(repoRoot, '.orchestrator', 'metrics', …)`
+ * recipes are one rename away from the planner deciding on one store while the
+ * runner rewrites another.
+ *
+ * @param {string} repoRoot
+ * @returns {{filePath: string, archivePath: string}}
+ */
+export function resolveLearningsPaths(repoRoot) {
+  const dir = path.join(repoRoot, '.orchestrator', 'metrics');
+  return {
+    filePath: path.join(dir, 'learnings.jsonl'),
+    archivePath: path.join(dir, 'learnings-archive.jsonl'),
+  };
+}
 
 // ---------------------------------------------------------------------------
 // Decision constructors
@@ -92,6 +132,23 @@ function mkProbeError(phase, err) {
   return decision(phase, true, `probe-error: ${msg}`, 'probe-error');
 }
 
+/** Phase ids retired on 2026-09-09 — kept in the plan, never decided. */
+const RETIRED_PHASES = new Set(['3.6.5', '3.6.7']);
+
+/** The reason string every retired phase carries, verbatim. */
+const RETIRED_REASON = 'retired 2026-09-09 — replaced by session-start maintenance-due probe';
+
+/**
+ * Permanent skip for a retired phase. No signal is read and no config key is
+ * consulted — not even a kill-switch, because there is nothing left to switch.
+ *
+ * @param {string} phase
+ * @returns {PhaseDecision}
+ */
+function mkRetired(phase) {
+  return mkSkip(phase, RETIRED_REASON, 'retired');
+}
+
 // ---------------------------------------------------------------------------
 // Config / platform helpers
 // ---------------------------------------------------------------------------
@@ -101,17 +158,6 @@ function isPersistenceOff(cfg) {
   return cfg && cfg.persistence === false;
 }
 
-/**
- * MEMORY.md (Auto-Dream signal source) lives under `~/.claude/projects/` — a
- * Claude Code-only path. Absent platform → treated as Claude Code (the common
- * coordinator context); any explicit non-Claude platform gates 3.6.5 off.
- */
-function isClaudePlatform(platform) {
-  if (platform === undefined || platform === null || platform === '') return true;
-  const p = String(platform).toLowerCase();
-  return p === 'claude' || p === 'claude-code' || p === 'claudecode';
-}
-
 // ---------------------------------------------------------------------------
 // Per-phase deciders — each wraps an EXISTING signal helper, config-gate first.
 // ---------------------------------------------------------------------------
@@ -149,14 +195,8 @@ async function decideMemoryProposals({ repoRoot, cfg }) {
 async function decideExpiredSweep({ repoRoot }) {
   const phase = '3.6.4';
   try {
-    const filePath = path.join(repoRoot, '.orchestrator', 'metrics', 'learnings.jsonl');
+    const { filePath, archivePath } = resolveLearningsPaths(repoRoot);
     if (!existsSync(filePath)) return mkSkip(phase, 'learnings.jsonl absent', 'learnings.jsonl');
-    const archivePath = path.join(
-      repoRoot,
-      '.orchestrator',
-      'metrics',
-      'learnings-archive.jsonl',
-    );
     const res = await sweepExpiredLearnings({ filePath, archivePath, dryRun: true });
     if (!res || res.archived === 0) {
       return mkSkip(phase, `nothing archive-eligible (scanned=${res?.scanned ?? 0})`, 'sweep-dry-run');
@@ -168,36 +208,6 @@ async function decideExpiredSweep({ repoRoot }) {
   }
 }
 
-/**
- * 3.6.5 Auto-Dream nudge (#502). Config gate (kill-switch threshold=0, platform)
- * → then `shouldDispatchAutoDream` (trigger:false branches → skip).
- */
-async function decideAutoDream({ repoRoot, cfg, platform, memoryDir }) {
-  const phase = '3.6.5';
-  try {
-    const threshold = cfg?.['memory-cleanup-threshold'] ?? 5;
-    if (threshold === 0) {
-      return mkSkip(phase, 'kill-switch (memory-cleanup-threshold=0)', 'config-gate');
-    }
-    if (!isClaudePlatform(platform)) {
-      return mkSkip(phase, 'non-Claude-Code platform (memory dir unavailable)', 'config-gate');
-    }
-    // #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,
-      threshold,
-      softLimit: cfg?.['memory-cleanup-soft-limit'] ?? 180,
-    });
-    if (!dec.trigger) return mkSkip(phase, dec.reason, 'auto-dream-signal');
-    return mkRun(phase, dec.reason, 'auto-dream-signal');
-  } catch (err) {
-    return mkProbeError(phase, err);
-  }
-}
-
 /**
  * 3.6.6 Skill-Applied Judge (#645 L3). Config gate (judge default OFF,
  * persistence) → then the judged-set emptiness check via
@@ -240,25 +250,6 @@ async function decideSkillJudge({ repoRoot, cfg, sessionId }) {
   }
 }
 
-/**
- * 3.6.7 Auto-Dialectic nudge (#506). Config gate (persistence, kill-switch
- * cadence=0) → then `shouldDispatchAutoDialectic` (the reference implementation
- * of the no-new-input-since-last-run pattern via `.orchestrator/dialectic-last-run`).
- */
-async function decideAutoDialectic({ repoRoot, cfg }) {
-  const phase = '3.6.7';
-  try {
-    if (isPersistenceOff(cfg)) return mkSkip(phase, 'persistence=false', 'config-gate');
-    const cadence = cfg?.dialectic?.cadence ?? 5;
-    if (cadence === 0) return mkSkip(phase, 'kill-switch (dialectic.cadence=0)', 'config-gate');
-    const dec = await shouldDispatchAutoDialectic({ repoRoot, cadence });
-    if (!dec.trigger) return mkSkip(phase, dec.reason, 'auto-dialectic-signal');
-    return mkRun(phase, dec.reason, 'auto-dialectic-signal');
-  } catch (err) {
-    return mkProbeError(phase, err);
-  }
-}
-
 /**
  * 3.6.8 Reconciliation Rule Proposals (#696). Config gate (persistence,
  * reconcile.enabled default OFF, learnings.jsonl present) → then `runReconcile`
@@ -354,37 +345,45 @@ export function buildSkippedReport(plan) {
 // ---------------------------------------------------------------------------
 
 /**
- * Compute the run/skip plan for the six session-end Phase 3.6.x tail phases.
+ * Compute the run/skip plan for the six session-end Phase 3.6.x tail phase ids
+ * — four decided from live signals, two permanently retired (see the module
+ * header). The plan keeps all six entries, in id order, so readers that index
+ * by phase id are unaffected by the retirement.
  *
- * NEVER throws — each phase probe fail-opens to `run: true`, and the top-level
- * guard converts any unexpected error into an all-run plan so the coordinator
- * runs the full tail rather than silently skipping it.
+ * NEVER throws — each live phase probe fail-opens to `run: true`, and the
+ * top-level guard converts any unexpected error into an all-run plan so the
+ * coordinator runs the full tail rather than silently skipping it. The two
+ * retired phases stay `run: false` even on that error path: fail-open exists to
+ * avoid LOSING a phase, and a retired phase has no procedure left to lose.
  *
  * @param {object} args
  * @param {string}  args.repoRoot   Absolute repo root.
  * @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(repoRoot)).
+ * @param {string}  [args.platform] ACCEPTED AND IGNORED since the 3.6.5 retirement
+ *   (2026-09-09) — the platform gate existed only for the Auto-Dream memory dir.
+ *   Kept in the signature because live callers still pass it.
+ * @param {string}  [args.memoryDir] ACCEPTED AND IGNORED, same reason as `platform`.
  * @returns {Promise<TailPlan>}
  */
-export async function planTailPhases({ repoRoot, config, sessionId, platform, memoryDir } = {}) {
+export async function planTailPhases({ repoRoot, config, sessionId } = {}) {
   const cfg = config ?? {};
   try {
     const plan = await Promise.all([
       decideMemoryProposals({ repoRoot, cfg }),
       decideExpiredSweep({ repoRoot }),
-      decideAutoDream({ repoRoot, cfg, platform, memoryDir }),
+      mkRetired('3.6.5'),
       decideSkillJudge({ repoRoot, cfg, sessionId }),
-      decideAutoDialectic({ repoRoot, cfg }),
+      mkRetired('3.6.7'),
       decideReconcile({ repoRoot, cfg }),
     ]);
     return { plan, skippedReport: buildSkippedReport(plan) };
   } catch (err) {
-    // Top-level fail-open guard: run the full tail rather than lose it silently.
+    // Top-level fail-open guard: run the full LIVE tail rather than lose it
+    // silently. Retired phases are never resurrected by an error.
     const msg = err && err.message ? err.message : String(err);
     const plan = ['3.6.3', '3.6.4', '3.6.5', '3.6.6', '3.6.7', '3.6.8'].map((p) =>
-      decision(p, true, `probe-error: ${msg}`, 'probe-error'),
+      RETIRED_PHASES.has(p) ? mkRetired(p) : decision(p, true, `probe-error: ${msg}`, 'probe-error'),
     );
     return { plan, skippedReport: buildSkippedReport(plan) };
   }