@tpsdev-ai/flair 0.48.0 → 0.50.0

package/dist/lib/mcp-enable.js

@@ -555,12 +555,57 @@ function opsBaseUrl(opsPortOrUrl) {
 function basicAuthHeader(adminUser, adminPass) {
     return `Basic ${Buffer.from(`${adminUser}:${adminPass}`).toString("base64")}`;
 }
+/** The resolver's own predicate, verbatim (resources/mcp-handler.ts
+ *  `resolveAgentFromSub`): a credential is resolvable unless it is explicitly
+ *  revoked. The linking layer MUST use the same test — a credential the linker
+ *  considers inactive but the resolver would still serve is exactly the
+ *  invisible-duplicate hole #1317 is about. */
+function isResolvableCredential(cred) {
+    return cred?.status !== "revoked";
+}
 /**
  * Map the operator's IdP subject to their principal via `Credential(kind:
  * "idp")` — the SAME credential surface resources/mcp-handler.ts's
- * `resolveAgentFromSub` reads at request time. Idempotent: an existing
- * mapping for (provider, subject) is reused (lastUsedAt bumped) rather than
- * duplicated; the principal Agent is created only if missing.
+ * `resolveAgentFromSub` reads at request time.
+ *
+ * ## The uniqueness constraint (flair#1317, K&S ruling 2026-08-21)
+ *
+ * **At most one ACTIVE `Credential(kind:"idp", idpSubject:<sub>)` exists at a
+ * time, regardless of `idpProvider`.** This function is where that invariant is
+ * enforced, because it is the only supported writer of the mapping.
+ *
+ * It used to dedup on `(kind, idpProvider, idpSubject)` while the resolver read
+ * `(kind, idpSubject)`. A re-link under a different provider name therefore
+ * matched nothing, INSERTED a second active credential, and left
+ * `resolveAgentFromSub` picking whichever row its search iterator served first
+ * — identity resolution by iteration order, on a security-relevant mapping.
+ *
+ * The resolver's key is the correct one and does not change: an IdP subject is
+ * an identity, and "who is this subject?" has exactly one answer. `idpProvider`
+ * stays on the row as audit/diagnostic metadata, but it does not participate in
+ * uniqueness. So:
+ *
+ *   - same provider, existing active credential → RE-POINT it (`credentialReused`);
+ *   - any OTHER active credential for the subject → SUPERSEDE it: terminal
+ *     `status: "revoked"`, never a soft flag a later path could flip back
+ *     (revoked rows are never reused here — a re-link after a revoke mints a
+ *     fresh credential);
+ *   - the re-point/insert and every revocation go out as ONE ops-API `upsert`
+ *     batch, so there is no observable window with two active credentials or
+ *     zero. If the batch fails, nothing is claimed and the call throws;
+ *   - after the write the invariant is RE-READ and asserted. A store that
+ *     somehow holds ≠1 active credential for the subject is a hard error, not a
+ *     silent nondeterministic mapping.
+ *
+ * The principal Agent is created only if missing.
+ *
+ * RESIDUAL RISK, by design (Sherlock, #1317): whoever can call this for a
+ * subject can revoke that subject's prior credential. If two genuinely
+ * different people ever shared a subject string across providers, one's link
+ * kills the other's mapping. IdP subjects are opaque per-IdP identifiers so the
+ * collision is remote, and the alternative — duplicate active credentials with
+ * order-dependent resolution — is strictly worse. `credentialSuperseded` exists
+ * so the operator is told, not so the event is hidden.
  */
 export async function provisionIdpIdentityMapping(params, deps = {}) {
     const fetchImpl = deps.fetchImpl ?? fetch;
@@ -628,26 +673,43 @@ export async function provisionIdpIdentityMapping(params, deps = {}) {
         }
         principalCreated = true;
     }
-    // Reuse an existing Credential(kind:idp, provider, subject) mapping if present.
-    const searchCredRes = await fetchImpl(opsUrl, {
-        method: "POST",
-        headers: { "Content-Type": "application/json", Authorization: authHeader },
-        body: JSON.stringify({
-            operation: "search_by_conditions",
-            database: "flair",
-            table: "Credential",
-            operator: "and",
-            conditions: [
-                { search_attribute: "kind", search_type: "equals", search_value: "idp" },
-                { search_attribute: "idpProvider", search_type: "equals", search_value: params.idpProvider },
-                { search_attribute: "idpSubject", search_type: "equals", search_value: params.idpSubject },
-            ],
-            get_attributes: ["id", "principalId"],
-        }),
-    });
-    const existingCreds = searchCredRes.ok ? await searchCredRes.json().catch(() => []) : [];
-    const existing = Array.isArray(existingCreds) ? existingCreds[0] : undefined;
-    const credentialId = existing?.id ?? `cred_idp_${params.idpProvider}_${randomBytes(6).toString("hex")}`;
+    // ── flair#1317: look SUBJECT-WIDE, not (provider, subject) ─────────────────
+    // The resolver's key is (kind, idpSubject); anything narrower here leaves
+    // credentials that dedup cannot see but resolution can.
+    const findCredentialsForSubject = async () => {
+        const res = await fetchImpl(opsUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json", Authorization: authHeader },
+            body: JSON.stringify({
+                operation: "search_by_conditions",
+                database: "flair",
+                table: "Credential",
+                operator: "and",
+                conditions: [
+                    { search_attribute: "kind", search_type: "equals", search_value: "idp" },
+                    { search_attribute: "idpSubject", search_type: "equals", search_value: params.idpSubject },
+                ],
+                get_attributes: ["id", "principalId", "idpProvider", "idpSubject", "status", "label", "createdAt"],
+            }),
+        });
+        const body = res.ok ? await res.json().catch(() => []) : [];
+        return Array.isArray(body) ? body : [];
+    };
+    const subjectCreds = await findCredentialsForSubject();
+    const activeCreds = subjectCreds.filter(isResolvableCredential);
+    // Survivor: an ACTIVE same-provider credential is re-pointed (the idempotent
+    // re-run and the documented same-provider link). A revoked one is never
+    // resurrected — a re-link after a revoke mints a fresh credential.
+    const reused = activeCreds.find((c) => c?.idpProvider === params.idpProvider && c?.id);
+    const credentialId = reused?.id ?? `cred_idp_${params.idpProvider}_${randomBytes(6).toString("hex")}`;
+    // Everything else active for this subject is superseded. Under the old
+    // (provider, subject) key these rows were simply invisible; they are what made
+    // resolution order-dependent.
+    const superseded = activeCreds.filter((c) => c?.id && c.id !== credentialId);
+    // ONE batched write: the survivor first, then the revocations. A single
+    // ops-API operation is the strongest atomicity this surface can express, and
+    // ordering the survivor first means even a partially-applied batch can never
+    // leave the subject with ZERO resolvable credentials (the fail-open denial).
     const upsertRes = await fetchImpl(opsUrl, {
         method: "POST",
         headers: { "Content-Type": "application/json", Authorization: authHeader },
@@ -664,9 +726,25 @@ export async function provisionIdpIdentityMapping(params, deps = {}) {
                     status: "active",
                     idpProvider: params.idpProvider,
                     idpSubject: params.idpSubject,
-                    createdAt: existing ? undefined : now,
+                    createdAt: reused ? undefined : now,
                     lastUsedAt: now,
                 },
+                // Retained, not deleted: the revocation stays legible in storage and in
+                // Harper's table audit log (which records the full record image of
+                // every write). Identifying fields are echoed back so the row survives
+                // as a well-formed, revoked credential whichever merge semantics the
+                // ops API applies.
+                ...superseded.map((c) => ({
+                    id: c.id,
+                    principalId: c.principalId,
+                    kind: "idp",
+                    label: c.label,
+                    status: "revoked",
+                    idpProvider: c.idpProvider,
+                    idpSubject: params.idpSubject,
+                    createdAt: c.createdAt,
+                    updatedAt: now,
+                })),
             ],
         }),
     });
@@ -674,7 +752,26 @@ export async function provisionIdpIdentityMapping(params, deps = {}) {
         const text = await upsertRes.text().catch(() => "");
         throw new Error(`Identity mapping: failed to write Credential(kind:idp) mapping (HTTP ${upsertRes.status}): ${text}`);
     }
-    return { principalCreated, credentialId, credentialReused: Boolean(existing) };
+    // ── The invariant, RE-READ ────────────────────────────────────────────────
+    // Asserting what we intended to write proves nothing. This asks the store.
+    // ≠1 active credential means the resolver's answer for this subject is
+    // order-dependent, so this fails LOUDLY rather than returning a mapping the
+    // operator would reasonably believe is deterministic.
+    const afterCreds = (await findCredentialsForSubject()).filter(isResolvableCredential);
+    if (afterCreds.length !== 1 || afterCreds[0]?.id !== credentialId) {
+        const seen = afterCreds.map((c) => `${c?.id} → ${c?.principalId} (provider '${c?.idpProvider}')`).join("; ") || "none";
+        throw new Error(`Identity mapping: the uniqueness invariant does not hold after the write — subject '${params.idpSubject}' ` +
+            `has ${afterCreds.length} active Credential(kind:idp) row(s) [${seen}], expected exactly 1 (${credentialId}). ` +
+            `Runtime resolution for this subject would be iteration-order-dependent (flair#1317). ` +
+            `Inspect the Credential table for kind:"idp" idpSubject:"${params.idpSubject}" and revoke the rows that should not resolve.`);
+    }
+    return {
+        principalCreated,
+        credentialId,
+        credentialReused: Boolean(reused),
+        credentialSuperseded: superseded.length > 0,
+        supersededCredentialIds: superseded.map((c) => String(c.id)),
+    };
 }
 // ─── Restart only ────────────────────────────────────────────────────────────
 /** `restart` only — used by `disableMcp` (flag off + restart, no config
@@ -1069,10 +1166,21 @@ export async function enableMcp(params, deps = {}) {
         // and the one silent failure mode this surface has is discovering that
         // via an empty bootstrap. So the step that creates the mapping states it
         // plainly, names the link remedy, and points at the runtime diagnostic.
+        // flair#1317 — a cross-provider re-link REVOKES the subject's prior
+        // credential (one active credential per subject is the invariant). That is
+        // a credential dying, so it is stated as such, by id: an operator must
+        // never discover it later from something that stopped working.
+        const supersedeNote = mapping.credentialSuperseded
+            ? ` SUPERSEDED: ${mapping.supersededCredentialIds.length} prior Credential(kind:idp) row(s) for this subject ` +
+                `were REVOKED, not de-duplicated — ${mapping.supersededCredentialIds.join(", ")}. ` +
+                `They no longer resolve, and anything relying on them stops working. ` +
+                `Exactly one active credential per (kind, idpSubject) is the invariant that keeps resolution deterministic.`
+            : "";
         push(true, `connector identity: sub '${params.idpSubject}' (provider '${idpProvider}') resolves to Agent '${principal}' — ` +
             `every /mcp call reads and writes AS '${principal}'. ` +
             `principal ${mapping.principalCreated ? "created" : "already existed"}; ` +
-            `Credential(kind:idp) ${mapping.credentialReused ? "re-pointed" : "created"} (${mapping.credentialId}). ` +
+            `Credential(kind:idp) ${mapping.credentialReused ? "re-pointed" : "created"} (${mapping.credentialId}).` +
+            `${supersedeNote} ` +
             `If your CLI signs as a DIFFERENT agent id, the connector sees that agent's DISTINCT memory scope (by design) — ` +
             `re-run with --principal <your-agent-id> to link them. ` +
             `Diagnostic: the bootstrap tool's agentId/scope fields always say who the server resolved you to.`);

package/dist/lib/scheduler-platform.js

@@ -20,9 +20,9 @@
  * in `verifyFirstRun()`: success may not be claimed until the thing the
  * operator asked for has been observed to happen once.
  */
-import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
-import { resolve, dirname, isAbsolute } from "node:path";
-import { platform } from "node:os";
+import { existsSync, mkdirSync, writeFileSync, readFileSync, realpathSync } from "node:fs";
+import { resolve, dirname, isAbsolute, basename } from "node:path";
+import { platform, userInfo } from "node:os";
 import { spawnSync } from "node:child_process";
 /**
  * 30s ceiling on launchctl/systemctl invocations so a hung service manager
@@ -90,20 +90,71 @@ export function interpretActiveResult(plat, code, stdout, stderr) {
         return null; // spawn itself failed — inconclusive
     return false; // covers the no-bus case: empty stdout, nonzero/failed exit
 }
+/** True when this session already has the env `systemctl --user` needs. */
+export function sessionHasUserBusEnv(env = process.env) {
+    return Boolean(env.XDG_RUNTIME_DIR?.trim() && env.DBUS_SESSION_BUS_ADDRESS?.trim());
+}
+/**
+ * Reads whether lingering is already enabled for the current user.
+ * `loginctl show-user … Linger=yes` is the official answer; the stamp file
+ * `loginctl enable-linger` creates is the fallback when loginctl is missing
+ * or inconclusive. A failed probe is `null`, never linger-off — inventing
+ * linger-off would repeat the linger remedy after it already ran (#1107).
+ */
+export function probeUserLingerEnabled(opts = {}) {
+    const run = opts.run ?? spawnReport;
+    const lingerStampExists = opts.lingerStampExists ?? ((u) => existsSync(`/var/lib/systemd/linger/${u}`));
+    let user = "";
+    try {
+        user = userInfo().username;
+    }
+    catch {
+        user = process.env.USER || process.env.LOGNAME || "";
+    }
+    if (!user)
+        return null;
+    const r = run(["loginctl", "show-user", user, "--property=Linger"], STATUS_CHECK_TIMEOUT_MS);
+    const m = /^Linger=(yes|no)\s*$/m.exec(r.stdout ?? "");
+    if (m)
+        return m[1] === "yes";
+    if (lingerStampExists(user))
+        return true;
+    return null;
+}
 /**
- * Human remedy text for a failed scheduler-load attempt (flair#850). Covers
- * the one root cause traced so far: a missing systemd user session bus,
- * which blocks `systemctl --user` entirely in ssh-without-lingering,
- * container, and CI contexts. Returns null when the failure doesn't match a
- * known pattern — the caller already prints the raw stderr, so the operator
- * still has something to go on.
+ * Human remedy text for a failed scheduler-load attempt (flair#850, #1107).
+ * Covers the traced "no systemd user session bus" failure, which blocks
+ * `systemctl --user` entirely in ssh-without-lingering, container, and CI
+ * contexts. Two cases that used to share one remedy:
+ *   (a) lingering genuinely off — print `loginctl enable-linger`
+ *   (b) linger already on, this session has no user-bus env — print the
+ *       `XDG_RUNTIME_DIR` / `DBUS_SESSION_BUS_ADDRESS` export lines
+ * Repeating (a) after the operator has applied it is the #1107 lie.
+ * Returns null when the failure doesn't match a known pattern — the caller
+ * already prints the raw stderr, so the operator still has something to go on.
  *
  * `enableCommand` is the caller's own enable invocation, named in the remedy
  * so the operator is told to re-run the command they actually ran.
  */
-export function describeLoadFailure(plat, loadResult, enableCommand) {
+export function describeLoadFailure(plat, loadResult, enableCommand, session) {
     const stderr = loadResult.stderr || "";
     if (plat === "linux" && /failed to connect to bus/i.test(stderr)) {
+        if (session?.lingerEnabled === true) {
+            const env = session.env ?? process.env;
+            if (!sessionHasUserBusEnv(env)) {
+                return ("No systemd user session bus is available in this session. Lingering is already enabled — " +
+                    "do not re-run `loginctl enable-linger`. The remaining gap is this session's user-bus environment. " +
+                    "Export:\n" +
+                    "     export XDG_RUNTIME_DIR=/run/user/$(id -u)\n" +
+                    "     export DBUS_SESSION_BUS_ADDRESS=unix:path=$XDG_RUNTIME_DIR/bus\n" +
+                    `   then re-run \`${enableCommand}\`.`);
+            }
+            return ("No systemd user session bus is available in this session. Lingering is already enabled and " +
+                "this session already has XDG_RUNTIME_DIR / DBUS_SESSION_BUS_ADDRESS — " +
+                "do not re-run `loginctl enable-linger` or re-export those variables. " +
+                "Check that `$XDG_RUNTIME_DIR/bus` exists (the systemd --user instance may not be running), " +
+                `then re-run \`${enableCommand}\`.`);
+        }
         return ("No systemd user session bus is available in this session (common over ssh without lingering, " +
             "in containers, or under CI). Fix: enable lingering for this user — `loginctl enable-linger <user>` " +
             `— then re-run \`${enableCommand}\`.`);
@@ -172,6 +223,77 @@ export function resolveNodeBin(explicit) {
         "enable time — refusing to install a shim that would resolve `node` from the service manager's PATH " +
         "at run time. Install node (or put it on PATH for this shell) and re-run enable.");
 }
+/**
+ * Resolves the path enable will bake as FLAIR_BIN, and whether that path is
+ * the stable public `flair` entry (flair#1279).
+ *
+ * Resolution order:
+ *   1. `explicit` — caller/test override. Relatives are resolved against cwd.
+ *   2. `hooks.argv1` / `process.argv[1]` — whatever launched enable.
+ *   3. The public `flair` on PATH, only when (1) and (2) are empty.
+ * Nothing absolute resolvable ⇒ throw. A bare `"flair"` is not an exec
+ * target under #1231's `exec <node> <script>` form (`node flair` looks in
+ * cwd, not PATH).
+ */
+export function resolveFlairBin(explicit, hooks) {
+    const publicBin = hooks && "publicBin" in hooks ? (hooks.publicBin ?? null) : lookupPublicFlairBin();
+    const captured = explicit ?? hooks?.argv1 ?? process.argv[1];
+    let path;
+    if (typeof captured === "string" && captured.length > 0) {
+        path = isAbsolute(captured) ? captured : resolve(captured);
+    }
+    else if (publicBin) {
+        path = publicBin;
+    }
+    else {
+        throw new Error("unable to resolve an absolute path to the flair CLI (process.argv[1] was empty and `command -v flair` " +
+            "found nothing). The scheduler shim bakes this path in at enable time — refusing to install a shim " +
+            "whose exec target is unknown. Re-run enable via the `flair` command.");
+    }
+    return { path, publicBin, canonical: isCanonicalFlairBin(path, publicBin) };
+}
+/** True when `baked` is the public `flair` entry, not a working-tree capture. */
+export function isCanonicalFlairBin(baked, publicBin) {
+    if (basename(baked) === "flair")
+        return true;
+    if (publicBin && pathsReferToSameFile(baked, publicBin))
+        return true;
+    return false;
+}
+/**
+ * The enable-report lines for a non-canonical FLAIR_BIN. Empty when the
+ * baked path is the public entry — callers should not print a warning then.
+ */
+export function formatFlairBinWarning(baked, publicBin, enableCommand) {
+    if (isCanonicalFlairBin(baked, publicBin))
+        return [];
+    const lines = [
+        `⚠️  FLAIR_BIN is ${baked} — that is the process that ran enable, not a stable public entry.`,
+        `   A later blue/green directory swap, or deleting this working tree, will strand the scheduler unit.`,
+    ];
+    if (publicBin) {
+        lines.push(`   Public \`flair\` on PATH: ${publicBin}. Re-run \`${enableCommand}\` as the \`flair\` command to bake that path instead.`);
+    }
+    else {
+        lines.push(`   No \`flair\` on PATH. Re-run \`${enableCommand}\` via the installed \`flair\` command (or a stable symlink) so the baked path survives a tree swap.`);
+    }
+    return lines;
+}
+function lookupPublicFlairBin() {
+    const r = spawnReport(["/bin/sh", "-c", "command -v flair"], STATUS_CHECK_TIMEOUT_MS);
+    const found = r.stdout.trim().split("\n")[0]?.trim() ?? "";
+    if (r.code === 0 && found && isAbsolute(found) && existsSync(found))
+        return found;
+    return null;
+}
+function pathsReferToSameFile(a, b) {
+    try {
+        return realpathSync(a) === realpathSync(b);
+    }
+    catch {
+        return resolve(a) === resolve(b);
+    }
+}
 // ─── first-run verification (flair#1231) ────────────────────────────────────
 // A load/bootstrap command exiting 0 proves the service manager accepted the
 // job — not that the job can run. The only vantage that exercises the real

package/dist/lib/scratch-owner.js

@@ -0,0 +1,49 @@
+/**
+ * Owner stamp for harness scratch directories (flair#1032).
+ *
+ * Directory mtime is not a liveness signal: on Linux, appending to files
+ * inside subdirectories does not update the parent. The stamp records the
+ * creating process; a sweep may delete a tree only when that process is gone
+ * (and, for Harper trees, when `hdb.pid` is gone too).
+ */
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+export const SCRATCH_OWNER_FILE = ".flair-scratch-owner";
+export function writeScratchOwnerStamp(dir, pid = process.pid) {
+    writeFileSync(join(dir, SCRATCH_OWNER_FILE), `${pid}\n`, { encoding: "utf-8" });
+}
+export function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function readPidFile(path) {
+    try {
+        const pid = Number(readFileSync(path, "utf-8").trim());
+        return Number.isInteger(pid) && pid > 0 ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function readScratchOwnerPid(dir) {
+    return readPidFile(join(dir, SCRATCH_OWNER_FILE));
+}
+export function hasScratchOwnerStamp(dir) {
+    return existsSync(join(dir, SCRATCH_OWNER_FILE));
+}
+/** True when the creating process is still alive. Unreadable stamp → not live. */
+export function scratchOwnerIsLive(dir) {
+    const pid = readScratchOwnerPid(dir);
+    return pid !== null && isPidAlive(pid);
+}
+export function hdbPidIsLive(dir) {
+    const pid = readPidFile(join(dir, "hdb.pid"));
+    return pid !== null && isPidAlive(pid);
+}

package/dist/rem/scheduler.js

@@ -19,7 +19,7 @@ import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { escapeXml } from "../lib/xml-escape.js";
-import { detectPlatform as detectPlatformFor, spawnReport, readTemplate as readTemplateFrom, renderTemplateWith, writeFileWithDir, interpretActiveResult, describeLoadFailure as describeLoadFailureFor, describeExitCode, resolveNodeBin, verifyFirstRun, STATUS_CHECK_TIMEOUT_MS, } from "../lib/scheduler-platform.js";
+import { detectPlatform as detectPlatformFor, spawnReport, readTemplate as readTemplateFrom, renderTemplateWith, writeFileWithDir, interpretActiveResult, describeLoadFailure as describeLoadFailureFor, describeExitCode, resolveNodeBin, resolveFlairBin, formatFlairBinWarning, verifyFirstRun, probeUserLingerEnabled, STATUS_CHECK_TIMEOUT_MS, } from "../lib/scheduler-platform.js";
 // Re-exported so this module's public surface is unchanged by the extraction
 // into src/lib/scheduler-platform.ts (a second scheduler — `flair federation
 // sync enable` — needs the identical launchctl/systemctl interpretation, and
@@ -180,8 +180,8 @@ export async function queryActiveStateAsync(plat, timeoutMs = STATUS_CHECK_TIMEO
  * known pattern — the caller already prints the raw stderr, so the operator
  * still has something to go on.
  */
-export function describeLoadFailure(plat, loadResult) {
-    return describeLoadFailureFor(plat, loadResult, "flair rem nightly enable");
+export function describeLoadFailure(plat, loadResult, session) {
+    return describeLoadFailureFor(plat, loadResult, "flair rem nightly enable", session);
 }
 /**
  * Formats the `flair rem nightly enable` report from an `EnableResult`.
@@ -199,6 +199,15 @@ export function describeLoadFailure(plat, loadResult) {
  * happen once. A missing `loadResult`/`firstRun` (test-only skipLoad shape)
  * therefore withholds the headline too, instead of being treated as success.
  */
+function appendFlairBinWarning(lines, r) {
+    if (r.flairBinCanonical !== false || !r.flairBin)
+        return;
+    const warning = formatFlairBinWarning(r.flairBin, r.flairBinPublic ?? null, "flair rem nightly enable");
+    if (warning.length === 0)
+        return;
+    lines.push("");
+    lines.push(...warning);
+}
 export function formatEnableReport(r, input) {
     const { hour, minute, agentId, flairUrl } = input;
     const scheduleTime = `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
@@ -216,11 +225,15 @@ export function formatEnableReport(r, input) {
         ];
         if (lr.stderr)
             lines.push(`     stderr: ${lr.stderr.trim()}`);
-        const remedy = describeLoadFailure(r.platform, lr);
+        const lingerEnabled = input.lingerEnabled !== undefined
+            ? input.lingerEnabled
+            : (r.platform === "linux" ? (input.probeLinger ?? probeUserLingerEnabled)() : undefined);
+        const remedy = describeLoadFailure(r.platform, lr, { lingerEnabled, env: input.env });
         lines.push("");
         lines.push(remedy ? `   ${remedy}` : `   Re-run the activation command above manually to see the full diagnostic.`);
         lines.push("");
         lines.push(`   Nothing is scheduled until activation succeeds. Check anytime with: flair rem nightly status`);
+        appendFlairBinWarning(lines, r);
         return { lines, ok: false };
     }
     if (!r.firstRunVerified) {
@@ -272,6 +285,7 @@ export function formatEnableReport(r, input) {
         }
         lines.push("");
         lines.push(`   Check anytime with: flair rem nightly status`);
+        appendFlairBinWarning(lines, r);
         return { lines, ok: false };
     }
     const lines = [
@@ -288,6 +302,7 @@ export function formatEnableReport(r, input) {
     lines.push(`   First run:   completed through the service manager, exit 0`);
     lines.push("");
     lines.push(`Disable with \`flair rem nightly disable\`.`);
+    appendFlairBinWarning(lines, r);
     return { lines, ok: true };
 }
 /**
@@ -329,7 +344,8 @@ export function formatStatusReport(s) {
  */
 export function enableScheduler(opts) {
     const plat = detectPlatform(opts.platformOverride);
-    const flairBin = opts.flairBin ?? process.argv[1] ?? "flair";
+    const resolvedFlair = resolveFlairBin(opts.flairBin);
+    const flairBin = resolvedFlair.path;
     const nodeBin = resolveNodeBin(opts.nodeBin);
     const shimPath = opts.shimPathOverride ?? SHIM_PATH_DEFAULT;
     const templateRoot = opts.templateRootOverride ?? defaultTemplateRoot();
@@ -383,6 +399,7 @@ export function enableScheduler(opts) {
         return {
             platform: plat, shimPath, schedulerPath: plistPath, loadCommand, loadResult,
             firstRunVerified: firstRun?.verified === true, firstRun,
+            flairBin, flairBinCanonical: resolvedFlair.canonical, flairBinPublic: resolvedFlair.publicBin,
         };
     }
     // Linux: systemd user units.
@@ -408,6 +425,7 @@ export function enableScheduler(opts) {
     return {
         platform: plat, shimPath, schedulerPath: timerPath, loadCommand, loadResult,
         firstRunVerified: firstRun?.verified === true, firstRun,
+        flairBin, flairBinCanonical: resolvedFlair.canonical, flairBinPublic: resolvedFlair.publicBin,
     };
 }
 /**

package/dist/resources/AgentSeed.js

@@ -19,6 +19,7 @@
 import { Resource, databases } from "harper";
 import { isAdmin, allowAdmin, invalidateAdminCache } from "./agent-auth.js";
 import { reconcileAdminFields } from "./agent-admin.js";
+import { noteMemoryUpsert } from "./bm25-index-service.js";
 const DEFAULT_SOUL_KEYS = (agentId, displayName, role, now) => ({
     name: displayName,
     role,
@@ -124,6 +125,7 @@ export class AgentSeed extends Resource {
                     archived: false,
                 };
                 await databases.flair.Memory.put(record);
+                noteMemoryUpsert(record);
                 memories.push(record);
             }
         } // end !hasOnboardingMemory

package/dist/resources/Memory.js

@@ -13,6 +13,7 @@ import { buildProvenance, makeAuthGate, makeReadScope, makeByIdReadGate, makeSco
 import { RECORD_TYPES } from "./record-types.js";
 import { attachTrust } from "./trust-block.js";
 import { recordCitations } from "./usage-recording.js";
+import { noteMemoryUpsert, noteMemoryDelete } from "./bm25-index-service.js";
 /**
  * flair#744 slice 1 — read the opt-in `includeTrust` flag for a by-id get.
  * Two entry shapes: an in-process caller (resources/mcp-tools.ts's memory_get)
@@ -306,7 +307,11 @@ async function closeSupersededRecord(ctx, oldId, patch) {
     if (!existing) {
         throw new Error(`supersede-close: record ${oldId} not found`);
     }
-    await withDetachedTxn(ctx, () => databases.flair.Memory.put({ ...existing, ...patch }));
+    const closed = { ...existing, ...patch };
+    await withDetachedTxn(ctx, () => databases.flair.Memory.put(closed));
+    // flair#1357 — a supersede-close sets `validTo`, which the retrieval filters
+    // read, so the lexical index has to see it as eagerly as a content write.
+    noteMemoryUpsert(closed);
 }
 /** Does an agent hold a "write" grant from `ownerId`? Same MemoryGrant lookup
  *  pattern as Memory.search()/SemanticSearch.ts (read/search scopes) — reused
@@ -766,6 +771,11 @@ export class Memory extends databases.flair.Memory {
         await stampOriginatorInstanceId(content);
         // ── Write the new record FIRST ──────────────────────────────────────────
         const result = await super.post(content);
+        // flair#1357 — read-your-write for the lexical leg. The table change feed
+        // (resources/bm25-index-service.ts) is the CORRECTNESS mechanism; this
+        // synchronous hook is what makes a store immediately searchable rather
+        // than searchable-after-the-feed-turns.
+        noteMemoryUpsert(content);
         // ── THEN close the superseded record ────────────────────────────────────
         // Write-new-BEFORE-close-old: the previous order (close-old via a fire-
         // and-forget `.catch(()=>{})` BEFORE the new write) could tombstone the
@@ -807,7 +817,9 @@ export class Memory extends databases.flair.Memory {
                 });
             }
             delete content._reindex;
-            return super.put(content);
+            const reindexed = await super.put(content);
+            noteMemoryUpsert(content);
+            return reindexed;
         }
         // Create/update ownership (same rule as post): a non-admin agent may only
         // write memories it owns, via resolveAgentAuth (gate annotation), not
@@ -1043,6 +1055,8 @@ export class Memory extends databases.flair.Memory {
         await stampOriginatorInstanceId(content);
         // ── Write the new/updated record FIRST ──────────────────────────────────
         const result = await super.put(content);
+        // flair#1357 — read-your-write for the lexical leg (see post()).
+        noteMemoryUpsert(content);
         // ── THEN close the superseded record (see post()) ───────────────────────
         await closeSupersededIfNeeded(ctx, content, "put");
         // flair#744 slice A: citation-on-write — POST-COMMIT, fully
@@ -1067,8 +1081,11 @@ export class Memory extends databases.flair.Memory {
         // before the read-gate fix — the read-scoping override must not leak
         // into delete()'s internal record lookup.
         const record = await super.get(id);
-        if (!record)
-            return super.delete(id);
+        if (!record) {
+            const gone = await super.delete(id);
+            noteMemoryDelete(id);
+            return gone;
+        }
         if (record.durability === "permanent") {
             // Middleware already guards this for non-admins, but belt-and-suspenders
             const ctx = this.getContext?.();
@@ -1081,6 +1098,8 @@ export class Memory extends databases.flair.Memory {
                 });
             }
         }
-        return super.delete(id);
+        const deleted = await super.delete(id);
+        noteMemoryDelete(id);
+        return deleted;
     }
 }

package/dist/resources/MemoryBootstrap.js

@@ -502,16 +502,18 @@ export class BootstrapMemories extends Resource {
                     skillAssignments.push(record);
                     continue;
                 }
-                // flair#1182 — the raw soul container (key→value), independent of the
-                // token-budgeted/priority-truncated `sections.soul` lines built below.
-                soulMap[record.key] = record.value;
                 const line = `**${record.key}:** ${record.value}`;
                 const tokens = estimateTokens(line);
                 const priority = SOUL_KEY_PRIORITY[record.key] ?? 50;
-                soulEntries.push({ key: record.key, line, tokens, priority });
+                soulEntries.push({ key: record.key, value: record.value, line, tokens, priority });
             }
             // Sort by priority (lower = more important)
             soulEntries.sort((a, b) => a.priority - b.priority);
+            // flair#1371 — the structured `soul` map follows the admission decision.
+            // Filling it during the scan (flair#1182) shipped every key even when
+            // this loop dropped the entry, so sections.soul / soulTokens / the
+            // context pointer described N while `soul` delivered N+1 (delivered
+            // but not counted or charged — the #1206 mirror).
             for (const entry of soulEntries) {
                 if (soulTokens + entry.tokens > soulMaxTokens) {
                     // Skip large entries that exceed budget — truncate or skip
@@ -522,6 +524,7 @@ export class BootstrapMemories extends Resource {
                     if (maxChars > 100) {
                         const truncated = `**${entry.key}:** ${entry.line.slice(entry.key.length + 6, entry.key.length + 6 + maxChars)}…(truncated)`;
                         sections.soul.push(truncated);
+                        soulMap[entry.key] = entry.value;
                         const cost = estimateTokens(truncated);
                         soulTokens += cost;
                         tokenBudget -= cost; // #1199 — soul draws from the shared budget
@@ -529,6 +532,7 @@ export class BootstrapMemories extends Resource {
                     continue;
                 }
                 sections.soul.push(entry.line);
+                soulMap[entry.key] = entry.value;
                 soulTokens += entry.tokens;
                 tokenBudget -= entry.tokens; // #1199 — soul draws from the shared budget
             }