@tpsdev-ai/flair 0.45.0 → 0.46.0

package/dist/lib/mcp-enable.js

@@ -306,7 +306,6 @@ export function buildMcpOAuthConfigBlock(params) {
     const provider = params.idpProvider;
     const envPrefix = `OAUTH_${provider.toUpperCase()}`;
     const cimdAllowedHosts = params.cimdAllowedHosts ?? DEFAULT_CIMD_ALLOWED_HOSTS;
-    const enabled = params.enabled ?? true;
     return {
         "@harperfast/oauth": {
             package: "@harperfast/oauth",
@@ -317,9 +316,29 @@ export function buildMcpOAuthConfigBlock(params) {
                 },
             },
             mcp: {
-                enabled,
+                // flair#1152: whole-token env reference — same flag flair's in-process
+                // route gates on. ASYMMETRY (load-bearing, measured on oauth 2.5.0):
+                // the component's coerceConfigBoolean accepts ONLY "true"/"false" and
+                // DELETES any other string (unresolved placeholder, "1", "yes",
+                // garbage) so its disabled default applies; flair's mcpOAuthEnabled()
+                // (resources/mcp-oauth-flag.ts) accepts 1/true/yes/on. So "true" is
+                // the one value that enables BOTH; "1"/"yes"/"on" flip flair's /mcp
+                // handler on while the component AS stays off (fail-closed broken-on:
+                // all 401, no AS advertised); garbage/unset disable both. On oauth
+                // <2.5.0 there is NO normalization and an unresolved placeholder is a
+                // truthy string (fail-open) — which is why the resolved-version
+                // assertion in mcp-oauth-boot-safety.test.ts exists. If component
+                // `enabled` semantics ever change, or it ever drives flair handler
+                // registration directly, re-derive this table before shipping.
+                enabled: "${FLAIR_MCP_OAUTH}",
                 issuer: "${FLAIR_MCP_ISSUER}",
-                resource: "${FLAIR_MCP_ISSUER}/mcp",
+                // flair#1180: NO `resource` key — the component's resolveResource()
+                // derives `<issuer>/mcp` at request time when it is absent, identical
+                // to flair's in-process derivation. The old composite
+                // "${FLAIR_MCP_ISSUER}/mcp" never interpolated (whole-token-only
+                // expansion) and failed every connect with invalid_target. Escape
+                // hatch: an operator needing a non-standard resource sets an explicit
+                // LITERAL absolute URL in config.yaml (never a composite).
                 accessTokenTtl: REQUIRED_ACCESS_TOKEN_TTL,
                 // Explicit fail-closed disable — see the doc comment above and the
                 // module header for why an omitted block is NOT equivalent to this.
@@ -336,14 +355,24 @@ export function buildMcpOAuthConfigBlock(params) {
     };
 }
 // ─── Local config.yaml update (flair#1136) ──────────────────────────────────
+/** The whole-token env reference `flair mcp enable` writes as mcp.enabled
+ *  (flair#1152). The on/off choice lives in the environment (the secrets
+ *  bundle stages FLAIR_MCP_OAUTH=true — see buildSecretsBundle for why it
+ *  must be "true"), never as a literal in the config file. */
+export const MCP_ENABLED_ENV_REFERENCE = "${FLAIR_MCP_OAUTH}";
 /**
- * Flip mcp.enabled in a local component config.yaml. Best-effort: returns
- * `{ ok: false }` with a reason when the file can't be found or parsed.
+ * Set mcp.enabled in a local component config.yaml to the flair#1152 shape.
+ * Best-effort: returns `{ ok: false }` with a reason when the file can't be
+ * found or parsed.
+ *
+ * `enabled: true` writes the WHOLE-TOKEN env reference ${FLAIR_MCP_OAUTH}
+ * (never a literal `true` — the env var, staged to `true` by the secrets bundle,
+ * carries the choice; a legacy literal `true` found in the file is normalized
+ * to the reference). `enabled: false` writes literal `false` — decisively off
+ * regardless of environment.
  *
  * Looks for config.yaml at `explicitPath`, then `./config.yaml`, then
- * `~/.flair/config.yaml`. When found, replaces `mcp:\n    enabled: false`
- * with `mcp:\n    enabled: true` (exact string match — avoids a YAML parser
- * dependency for a single boolean flip).
+ * `~/.flair/config.yaml`.
  */
 export function updateLocalConfigMcpEnabled(enabled, explicitPath) {
     const candidates = explicitPath
@@ -356,11 +385,15 @@ export function updateLocalConfigMcpEnabled(enabled, explicitPath) {
             break;
         }
     }
+    // The value the file should carry for this call (flair#1152): the env
+    // reference when enabling, literal false when disabling.
+    const target = enabled ? MCP_ENABLED_ENV_REFERENCE : false;
+    const targetLabel = enabled ? `${MCP_ENABLED_ENV_REFERENCE} (env-referenced)` : "false";
     if (!configPath) {
         return {
             ok: false,
             detail: `local config.yaml not found (tried: ${candidates.join(", ")}). ` +
-                `Set mcp.enabled: ${enabled} in your component config.yaml manually, then restart.`,
+                `Set mcp.enabled: ${targetLabel} in your component config.yaml manually, then restart.`,
         };
     }
     let raw;
@@ -388,7 +421,7 @@ export function updateLocalConfigMcpEnabled(enabled, explicitPath) {
         return {
             ok: false,
             detail: `@harperfast/oauth block not found in ${configPath}. ` +
-                `Ensure the component block is present with mcp.enabled: ${enabled}.`,
+                `Ensure the component block is present with mcp.enabled: ${targetLabel}.`,
         };
     }
     const mcp = oauth.mcp;
@@ -396,15 +429,15 @@ export function updateLocalConfigMcpEnabled(enabled, explicitPath) {
         return {
             ok: false,
             detail: `mcp key not found under @harperfast/oauth in ${configPath}. ` +
-                `Ensure the mcp block is present with enabled: ${enabled}.`,
+                `Ensure the mcp block is present with enabled: ${targetLabel}.`,
         };
     }
     const current = mcp.enabled;
-    if (current === enabled) {
-        return { ok: true, detail: `mcp.enabled already ${enabled} in ${configPath}` };
+    if (current === target) {
+        return { ok: true, detail: `mcp.enabled already ${targetLabel} in ${configPath}` };
     }
     // Mutate the parsed document and re-emit.
-    mcp.enabled = enabled;
+    mcp.enabled = target;
     const updated = yaml.dump(doc, { lineWidth: -1, noCompatMode: true });
     try {
         writeFileSync(configPath, updated, { encoding: "utf-8" });
@@ -412,7 +445,7 @@ export function updateLocalConfigMcpEnabled(enabled, explicitPath) {
     catch (err) {
         return { ok: false, detail: `cannot write ${configPath}: ${err.message}` };
     }
-    return { ok: true, detail: `mcp.enabled set to ${enabled} in ${configPath}` };
+    return { ok: true, detail: `mcp.enabled set to ${targetLabel} in ${configPath}` };
 }
 /** The exact callback URL to hand the operator when they create the IdP
  *  OAuth app ("with the exact GitHub callback URL printed"). */
@@ -425,7 +458,14 @@ export function idpCallbackUrl(issuer, idpProvider) {
 export function buildSecretsBundle(params) {
     const envPrefix = `OAUTH_${params.idpProvider.toUpperCase()}`;
     return {
-        FLAIR_MCP_OAUTH: "1",
+        // "true" is the ONLY value both readers of this flag accept (flair#1152,
+        // measured against oauth 2.5.0): flair's strict mcpOAuthEnabled() takes
+        // 1/true/yes/on, but the component's coerceConfigBoolean takes ONLY
+        // "true"/"false" and DELETES anything else (disabled default applies).
+        // Staging "1" here would flip flair's /mcp handler ON while the
+        // component's AS stays OFF — fail-closed but broken-on (every request
+        // 401s, no AS is advertised). Keep this "true".
+        FLAIR_MCP_OAUTH: "true",
         FLAIR_MCP_ISSUER: params.issuer.replace(/\/+$/, ""),
         FLAIR_MCP_SIGNING_KEY_PEM: params.signingKeyPem,
         [`${envPrefix}_CLIENT_ID`]: params.idpClientId,
@@ -1052,9 +1092,9 @@ export async function enableMcp(params, deps = {}) {
             currentStep = "fabric-operator-deploy";
             const msg = [
                 `Fabric deployment detected (${new URL(params.instance).hostname}).`,
-                `The @harperfast/oauth block ships in config.yaml with mcp.enabled: false.`,
-                `To activate: set mcp.enabled: true (literal boolean) in your deployed component config.yaml,`,
-                `ensure the staged secrets are live in the instance's process environment, and redeploy.`,
+                `The @harperfast/oauth block ships in config.yaml with mcp.enabled: \${FLAIR_MCP_OAUTH} (env-referenced, flair#1152) — no config edit is needed.`,
+                `To activate: apply the staged secrets (FLAIR_MCP_OAUTH=true among them) to the instance's environment (Fabric env), then restart the instance.`,
+                `Deploys can no longer revert the choice — it lives in the environment, not the packed file.`,
                 `Then re-run \`flair mcp enable\` — earlier steps are idempotent and will be reused.`,
             ].join(" ");
             push(false, msg);

package/dist/lib/scheduler-platform.js

@@ -13,9 +13,15 @@
  *
  * `interpretActiveResult()` in particular encodes a production lesson
  * (flair#850) that took a real outage to learn. It must not be re-derived.
+ * flair#1231 extended it one layer deeper: a load command exiting 0 proves the
+ * service manager ACCEPTED the job, not that the job can RUN — two fleet
+ * incidents (a stripped exec bit, a missing log directory) both passed the
+ * load check and died on the first real run, invisibly. The rule now encoded
+ * 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 } from "node:path";
+import { resolve, dirname, isAbsolute } from "node:path";
 import { platform } from "node:os";
 import { spawnSync } from "node:child_process";
 /**
@@ -126,3 +132,206 @@ export function writeFileWithDir(path, contents, mode = 0o600) {
         mkdirSync(dir, { recursive: true, mode: 0o700 });
     writeFileSync(path, contents, { mode });
 }
+// ─── node binary resolution (flair#1231) ────────────────────────────────────
+/**
+ * Resolves the ABSOLUTE path to the node binary at enable time, so the shim
+ * can `exec "<node>" "<script>"` with ZERO PATH lookups at run time.
+ *
+ * Why this exists: the shims switched from `exec "{{FLAIR_BIN}}"` (which
+ * required an exec bit that tarball extraction strips — the #1231 regression)
+ * to running the CLI under node, which needs read permission only. But a bare
+ * `exec node …` would introduce a run-time PATH lookup the old absolute-path
+ * form never had: whatever PATH the service manager's environment carries
+ * would pick the `node` that runs with the operator's credentials. So the
+ * node path is resolved HERE, once, from the enabling process's own
+ * environment, and baked into the shim — symmetric with how FLAIR_BIN is
+ * already handled.
+ *
+ * Resolution order:
+ *   1. `explicit` — caller/test override.
+ *   2. `process.execPath` when the enabling runtime IS node (the published
+ *      CLI's case): absolute, known-good, already trusted to run this code.
+ *   3. `command -v node` in the enabling shell environment (dev/test under
+ *      bun): the one deliberate PATH consultation, made at enable time by the
+ *      operator's own session, never later by the service manager.
+ * Nothing resolvable ⇒ throw — enable must fail loudly rather than bake a
+ * run-time lookup into the shim.
+ */
+export function resolveNodeBin(explicit) {
+    if (explicit)
+        return explicit;
+    if (!process.versions.bun && process.execPath && isAbsolute(process.execPath)) {
+        return process.execPath;
+    }
+    const r = spawnReport(["/bin/sh", "-c", "command -v node"], STATUS_CHECK_TIMEOUT_MS);
+    const found = r.stdout.trim().split("\n")[0]?.trim() ?? "";
+    if (r.code === 0 && found && isAbsolute(found) && existsSync(found))
+        return found;
+    throw new Error("unable to resolve an absolute path to a node binary (not running under node, and `command -v node` " +
+        "found nothing). The scheduler shim runs `<node> <flair-script>` with the node path baked in at " +
+        "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.");
+}
+// ─── 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
+// failure modes (launchd spawn error 209 from a missing log dir, exit 126
+// from a stripped exec bit) is the service manager itself, so the first run
+// is triggered and observed THROUGH it, never via a bare spawn of the shim.
+/** Poll cadence for darwin `launchctl print` first-run polling. */
+export const FIRST_RUN_POLL_INTERVAL_MS = 150;
+/** Total budget for first-run verification on both platforms. */
+export const FIRST_RUN_BUDGET_MS = 12_000;
+/** Synchronous sleep without spawning anything. */
+function sleepSync(ms) {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+/**
+ * Parses `launchctl print <domain>/<label>` for run state. `last exit code`
+ * is absent (or "(never exited)") until a run has completed, and `pid =` /
+ * `state = running` are present only while one is in flight.
+ */
+export function parseLaunchdPrintExit(output) {
+    const running = /^\s*state\s*=\s*(?:running|spawn)/m.test(output) || /^\s*pid\s*=\s*\d+/m.test(output);
+    const m = /last exit (?:code|status)\s*=\s*(-?\d+)/.exec(output);
+    return { running, lastExitCode: m ? Number(m[1]) : null };
+}
+/** Parses `systemctl --user show <unit> --property=ExecMainStatus,Result`. */
+export function parseSystemdShowExit(output) {
+    const m = /^ExecMainStatus=(-?\d+)\s*$/m.exec(output);
+    const r = /^Result=(\S+)\s*$/m.exec(output);
+    return { execMainStatus: m ? Number(m[1]) : null, result: r ? r[1] : null };
+}
+/** Reads the last lines of a log file for failure diagnostics. Never throws. */
+export function readLogTail(path, maxLines = 12, maxChars = 1500) {
+    let text;
+    try {
+        text = readFileSync(path, "utf-8");
+    }
+    catch {
+        return { exists: false, empty: false, tail: "" };
+    }
+    const trimmed = text.trimEnd();
+    if (!trimmed)
+        return { exists: true, empty: true, tail: "" };
+    let tail = trimmed.split("\n").slice(-maxLines).join("\n");
+    if (tail.length > maxChars)
+        tail = tail.slice(-maxChars);
+    return { exists: true, empty: false, tail };
+}
+/**
+ * Names the failure class for a recorded exit status, so the report can lead
+ * with actor+state instead of a bare number.
+ */
+export function describeExitCode(code) {
+    if (code === null)
+        return "no exit status recorded";
+    if (code === 126)
+        return "exit 126 — found but not runnable (permission denied / exec format)";
+    if (code === 127)
+        return "exit 127 — command not found";
+    if (code === 209)
+        return "exit 209 — launchd could not spawn the job (a missing/unwritable log directory produces this)";
+    return `exit ${code}`;
+}
+function spawnedNothing(r) {
+    return r.code === null && !r.stdout.trim() && !r.stderr.trim();
+}
+/**
+ * Triggers the job's first run through the service manager and reads back how
+ * it ended (flair#1231). Call ONLY after the load/bootstrap command exited 0 —
+ * a load failure is its own failure mode with its own remedy, and layering a
+ * kickstart on top of it would blur which actor failed.
+ *
+ * darwin: `launchctl kickstart -k` returns immediately (it does NOT block for
+ * exit), so the recorded exit status is POLLED out of `launchctl print` until
+ * a completed run is visible or the budget lapses. linux: `systemctl --user
+ * start` on a oneshot blocks until the run exits, so a single
+ * `systemctl --user show` read afterwards suffices.
+ *
+ * "Can't tell" is its own state: a missing/unreachable service manager yields
+ * outcome "manager-unavailable", distinct from "run-failed" — the remedy
+ * points at the service manager, not at the job.
+ */
+export function verifyFirstRun(opts) {
+    const run = opts.hooks?.run ?? ((cmd, timeoutMs) => spawnReport(cmd, timeoutMs));
+    const sleep = opts.hooks?.sleep ?? sleepSync;
+    const now = opts.hooks?.now ?? Date.now;
+    const pollIntervalMs = opts.pollIntervalMs ?? FIRST_RUN_POLL_INTERVAL_MS;
+    const budgetMs = opts.budgetMs ?? FIRST_RUN_BUDGET_MS;
+    const finish = (outcome, exitCode, detail) => {
+        const log = outcome === "success"
+            ? { exists: false, empty: false, tail: "" } // no diagnostics needed on success
+            : readLogTail(opts.stderrLogPath);
+        return {
+            verified: outcome === "success",
+            outcome,
+            exitCode,
+            detail,
+            logPath: opts.stderrLogPath,
+            stderrTail: log.tail,
+            logEmpty: log.exists && log.empty,
+            budgetMs,
+        };
+    };
+    if (opts.plat === "darwin") {
+        const target = opts.darwinTarget;
+        if (!target)
+            throw new Error("verifyFirstRun: darwinTarget is required on darwin");
+        const kickCmd = ["launchctl", "kickstart", "-k", target];
+        const kick = run(kickCmd, SPAWN_TIMEOUT_MS);
+        if (spawnedNothing(kick)) {
+            return finish("manager-unavailable", null, `launchctl could not be run (${kickCmd.join(" ")})`);
+        }
+        if (kick.code !== 0) {
+            return finish("start-failed", null, `${kickCmd.join(" ")} → code ${kick.code}${kick.stderr.trim() ? `: ${kick.stderr.trim()}` : ""}`);
+        }
+        const deadline = now() + budgetMs;
+        // Poll: kickstart returned immediately, so watch `launchctl print` until a
+        // COMPLETED run (not running + a recorded exit code) is visible.
+        for (;;) {
+            const printCmd = ["launchctl", "print", target];
+            const r = run(printCmd, STATUS_CHECK_TIMEOUT_MS);
+            if (spawnedNothing(r)) {
+                return finish("manager-unavailable", null, `launchctl could not be run (${printCmd.join(" ")})`);
+            }
+            if (r.code === 0) {
+                const { running, lastExitCode } = parseLaunchdPrintExit(r.stdout);
+                if (!running && lastExitCode !== null) {
+                    return lastExitCode === 0
+                        ? finish("success", 0, `${printCmd.join(" ")} → last exit code = 0`)
+                        : finish("run-failed", lastExitCode, `${printCmd.join(" ")} → last exit code = ${lastExitCode}`);
+                }
+            }
+            if (now() >= deadline) {
+                return finish("timeout", null, `no completed run visible in ${printCmd.join(" ")} within ${Math.round(budgetMs / 1000)}s`);
+            }
+            sleep(pollIntervalMs);
+        }
+    }
+    // linux
+    const unit = opts.linuxServiceUnit;
+    if (!unit)
+        throw new Error("verifyFirstRun: linuxServiceUnit is required on linux");
+    const startCmd = ["systemctl", "--user", "start", unit];
+    const start = run(startCmd, budgetMs);
+    if (spawnedNothing(start)) {
+        return finish("manager-unavailable", null, `systemctl could not be run (${startCmd.join(" ")})`);
+    }
+    if (/failed to connect to bus/i.test(start.stderr)) {
+        return finish("manager-unavailable", null, `${startCmd.join(" ")} → ${start.stderr.trim()}`);
+    }
+    if (start.code === null) {
+        return finish("timeout", null, `${startCmd.join(" ")} did not return within ${Math.round(budgetMs / 1000)}s`);
+    }
+    const showCmd = ["systemctl", "--user", "show", unit, "--property=ExecMainStatus,Result"];
+    const show = run(showCmd, STATUS_CHECK_TIMEOUT_MS);
+    const parsed = parseSystemdShowExit(show.stdout);
+    if (start.code === 0) {
+        // A blocking start of a oneshot exits 0 only when the run succeeded; the
+        // show read supplies the recorded status for the report.
+        return finish("success", parsed.execMainStatus ?? 0, `${startCmd.join(" ")} → ok`);
+    }
+    const resultTxt = parsed.result ? `, Result=${parsed.result}` : "";
+    return finish("run-failed", parsed.execMainStatus, `${startCmd.join(" ")} → code ${start.code}${resultTxt}${start.stderr.trim() ? `: ${start.stderr.trim()}` : ""}`);
+}

package/dist/rem/scheduler.js

@@ -13,13 +13,13 @@
  * No daemon code lives here — the scheduler invokes the shim, the shim
  * invokes `flair rem nightly run-once`, the runner module does the work.
  */
-import { existsSync, chmodSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, chmodSync, rmSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 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, 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, verifyFirstRun, 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
@@ -87,15 +87,16 @@ function validateSchedule(hour, minute) {
         throw new Error(`minute must be an integer 0-59, got ${minute}`);
     }
 }
-function buildSubstitutions(opts, shimPath, flairBin) {
+function buildSubstitutions(opts, shimPath, flairBin, nodeBin) {
     validateSchedule(opts.hour, opts.minute);
     if (!/^[a-zA-Z0-9_-]+$/.test(opts.agentId)) {
         throw new Error(`invalid agent id: ${opts.agentId}`);
     }
     return {
         FLAIR_BIN: flairBin,
+        NODE_BIN: nodeBin,
         SHIM_PATH: shimPath,
-        HOME: homedir(),
+        HOME: opts.homeOverride ?? homedir(),
         AGENT_ID: opts.agentId,
         FLAIR_URL: opts.flairUrl,
         HOUR: String(opts.hour),
@@ -183,10 +184,14 @@ export function describeLoadFailure(plat, loadResult) {
  * succeeded) is unit-testable without spawning a real launchctl/systemctl or
  * parsing CLI argv.
  *
- * `r.loadResult` is only set when the load command actually ran (the CLI
- * never sets `skipLoad`). A missing `loadResult` (test-only path) is treated
- * as success — matches the CLI's real-world behavior, which always runs the
- * load command and therefore always gets a `loadResult`.
+ * flair#1231 deepened the #850 rule by one layer: activation exiting 0 proves
+ * the service manager ACCEPTED the job, not that the job can run — a stripped
+ * exec bit and a missing log directory both passed activation and killed the
+ * first real run invisibly. So the ✅ headline is now additionally gated on
+ * `firstRunVerified`: success may not be claimed until the thing the operator
+ * asked for — a REM run through the service manager — has been observed to
+ * happen once. A missing `loadResult`/`firstRun` (test-only skipLoad shape)
+ * therefore withholds the headline too, instead of being treated as success.
  */
 export function formatEnableReport(r, input) {
     const { hour, minute, agentId, flairUrl } = input;
@@ -212,6 +217,57 @@ export function formatEnableReport(r, input) {
         lines.push(`   Nothing is scheduled until activation succeeds. Check anytime with: flair rem nightly status`);
         return { lines, ok: false };
     }
+    if (!r.firstRunVerified) {
+        const fr = r.firstRun;
+        const headline = fr?.outcome === "run-failed"
+            ? `⚠️  REM nightly scheduler installed but the first run FAILED (${describeExitCode(fr.exitCode)})`
+            : fr?.outcome === "timeout"
+                ? `⚠️  REM nightly scheduler installed but the first run did not complete within ${Math.round(fr.budgetMs / 1000)}s — cannot confirm it works`
+                : fr?.outcome === "manager-unavailable"
+                    ? `⚠️  REM nightly scheduler installed but the service manager is unreachable — cannot verify the first run`
+                    : fr?.outcome === "start-failed"
+                        ? `⚠️  REM nightly scheduler installed but the first run could not be started`
+                        : `⚠️  REM nightly scheduler installed but the first run was never verified`;
+        const lines = [
+            headline,
+            `   Schedule:    ${scheduleTime} local time`,
+            `   Scheduler:   ${r.schedulerPath}`,
+            `   Shim:        ${r.shimPath}`,
+            `   Agent:       ${agentId}`,
+            `   Flair URL:   ${flairUrl}`,
+        ];
+        if (r.loadResult)
+            lines.push(`   Load:        ${r.loadCommand.join(" ")} → ok`);
+        if (fr) {
+            lines.push(`   First run:   ${fr.detail}`);
+            if (fr.stderrTail) {
+                lines.push(`   Log tail (${fr.logPath}):`);
+                for (const l of fr.stderrTail.split("\n"))
+                    lines.push(`     ${l}`);
+            }
+            else if (fr.logEmpty) {
+                lines.push(`   Log file ${fr.logPath} exists but is EMPTY — the run died before writing anything.`);
+            }
+            else {
+                lines.push(`   No log file at ${fr.logPath}.`);
+            }
+        }
+        lines.push("");
+        if (fr?.outcome === "timeout") {
+            lines.push(`   The run may legitimately still be going (a REM cycle can be slow). Check the log above and`);
+            lines.push(`   \`flair rem nightly status\`; no cycle has been CONFIRMED to work yet.`);
+        }
+        else if (fr?.outcome === "manager-unavailable") {
+            lines.push(`   The scheduler files are installed, but launchctl/systemctl could not be consulted, so whether`);
+            lines.push(`   the nightly cycle runs is UNKNOWN. Fix the service manager for this session, then re-run \`flair rem nightly enable\`.`);
+        }
+        else {
+            lines.push(`   No REM cycle has run. Fix the cause above, then re-run \`flair rem nightly enable\`.`);
+        }
+        lines.push("");
+        lines.push(`   Check anytime with: flair rem nightly status`);
+        return { lines, ok: false };
+    }
     const lines = [
         `✅ REM nightly scheduler enabled (${r.platform})`,
         `   Schedule:    ${scheduleTime} local time`,
@@ -223,9 +279,9 @@ export function formatEnableReport(r, input) {
     if (r.loadResult) {
         lines.push(`   Load:        ${r.loadCommand.join(" ")} → ok`);
     }
+    lines.push(`   First run:   completed through the service manager, exit 0`);
     lines.push("");
-    lines.push(`Tip: run \`flair rem nightly run-once --dry-run\` to verify the cycle works`);
-    lines.push(`     before the first scheduled fire. Disable with \`flair rem nightly disable\`.`);
+    lines.push(`Disable with \`flair rem nightly disable\`.`);
     return { lines, ok: true };
 }
 /**
@@ -268,9 +324,29 @@ export function formatStatusReport(s) {
 export function enableScheduler(opts) {
     const plat = detectPlatform(opts.platformOverride);
     const flairBin = opts.flairBin ?? process.argv[1] ?? "flair";
+    const nodeBin = resolveNodeBin(opts.nodeBin);
     const shimPath = opts.shimPathOverride ?? SHIM_PATH_DEFAULT;
     const templateRoot = opts.templateRootOverride ?? defaultTemplateRoot();
-    const subs = buildSubstitutions(opts, shimPath, flairBin);
+    const subs = buildSubstitutions(opts, shimPath, flairBin, nodeBin);
+    // 0. Create the log directory the unit files point stdout/stderr at.
+    // Nothing else ever creates it — launchd kills a job whose StandardOutPath
+    // directory is missing (spawn error 209) and systemd fails the unit (#1231).
+    //
+    // Mode 0700 is load-bearing, NOT cosmetic: REM's nightly log carries
+    // distillation CANDIDATE CONTENT — actual memory text, not just counts.
+    // Relaxing it to 0755 (e.g. "for shared debugging") would expose memory
+    // content to every local user.
+    const logsDir = resolve(subs.HOME, ".flair", "logs");
+    try {
+        mkdirSync(logsDir, { recursive: true, mode: 0o700 });
+    }
+    catch (err) {
+        throw new Error(`could not create the scheduler log directory ${logsDir}: ${err?.message ?? err}. ` +
+            `The service manager writes the job's stdout/stderr there; without it the first run dies ` +
+            `before producing any output. Fix whatever blocks creating that directory, then re-run ` +
+            `\`flair rem nightly enable\`.`);
+    }
+    const stderrLogPath = resolve(logsDir, "rem-nightly.stderr.log");
     // 1. Deploy the shim (always — both platforms invoke it).
     const shimContents = renderTemplate(readTemplate(templateRoot, "bin/flair-rem-nightly.sh.tmpl"), subs);
     writeFileWithDir(shimPath, shimContents, 0o700);
@@ -282,12 +358,26 @@ export function enableScheduler(opts) {
         writeFileWithDir(plistPath, plistContents, 0o600);
         const loadCommand = ["launchctl", "bootstrap", `gui/${process.getuid?.() ?? ""}`, plistPath];
         let loadResult;
+        let firstRun;
         if (!opts.skipLoad) {
             // Bootout first in case a prior install left the job loaded.
             spawnReport(["launchctl", "bootout", `gui/${process.getuid?.() ?? ""}`, plistPath]);
             loadResult = spawnReport(loadCommand);
+            if (loadResult.code === 0) {
+                // Ordering gate (#1231): verify the first run ONLY after the load
+                // exited 0. A load failure is its own failure mode with its own
+                // remedy — kickstarting on top of it would blur which actor failed.
+                firstRun = verifyFirstRun({
+                    plat,
+                    darwinTarget: `gui/${process.getuid?.() ?? ""}/dev.flair.rem.nightly`,
+                    stderrLogPath,
+                });
+            }
         }
-        return { platform: plat, shimPath, schedulerPath: plistPath, loadCommand, loadResult };
+        return {
+            platform: plat, shimPath, schedulerPath: plistPath, loadCommand, loadResult,
+            firstRunVerified: firstRun?.verified === true, firstRun,
+        };
     }
     // Linux: systemd user units.
     const timerPath = opts.systemdTimerOverride ?? SYSTEMD_TIMER_PATH;
@@ -298,11 +388,21 @@ export function enableScheduler(opts) {
     writeFileWithDir(timerPath, timerContents, 0o600);
     const loadCommand = ["systemctl", "--user", "enable", "--now", "flair-rem-nightly.timer"];
     let loadResult;
+    let firstRun;
     if (!opts.skipLoad) {
         spawnReport(["systemctl", "--user", "daemon-reload"]);
         loadResult = spawnReport(loadCommand);
+        if (loadResult.code === 0) {
+            // Ordering gate (#1231): only after the load exited 0. Starts the
+            // SERVICE unit directly (oneshot ⇒ blocks until the run exits) rather
+            // than waiting for the nightly timer to fire.
+            firstRun = verifyFirstRun({ plat, linuxServiceUnit: "flair-rem-nightly.service", stderrLogPath });
+        }
     }
-    return { platform: plat, shimPath, schedulerPath: timerPath, loadCommand, loadResult };
+    return {
+        platform: plat, shimPath, schedulerPath: timerPath, loadCommand, loadResult,
+        firstRunVerified: firstRun?.verified === true, firstRun,
+    };
 }
 /**
  * Removes the scheduler entry. Audit log + snapshots are preserved.

package/dist/resources/MemoryMaintenance.js

@@ -54,8 +54,14 @@ export class MemoryMaintenance extends Resource {
                 if (targetAgent && record.agentId !== targetAgent)
                     continue;
                 stats.total++;
-                // 1. Delete expired memories
-                if (record.expiresAt && new Date(record.expiresAt) < now) {
+                // 1. Delete expired ephemeral memories. expiresAt is only a reap
+                // signal for the ephemeral tier (docstring + Memory.post() TTL
+                // stamp). A non-ephemeral row that acquired one (bug, import, API
+                // misuse) must survive — missing / unexpected durability is treated
+                // as non-ephemeral so we do not silently reap durable rows.
+                if (record.durability === "ephemeral" &&
+                    record.expiresAt &&
+                    new Date(record.expiresAt) < now) {
                     if (!dryRun) {
                         try {
                             await databases.flair.Memory.delete(record.id);

package/dist/resources/mcp-oauth-flag.js

@@ -28,6 +28,26 @@
  *
  * Read from `FLAIR_MCP_OAUTH` — truthy values: "1", "true", "yes", "on"
  * (case-insensitive). Anything else (incl. unset / empty) → OFF.
+ *
+ * ASYMMETRY (load-bearing, flair#1152, measured on oauth 2.5.0): config.yaml's
+ * `mcp.enabled: ${FLAIR_MCP_OAUTH}` hands the SAME env var to
+ * @harperfast/oauth, but the two readers accept DIFFERENT vocabularies. The
+ * component's coerceConfigBoolean takes ONLY "true"/"false" and DELETES any
+ * other string (unresolved placeholder, "1", "yes", garbage) so its disabled
+ * default applies; this function takes 1/true/yes/on. Consequences:
+ *   - "true" is the ONE value that enables both sides (`flair mcp enable`
+ *     stages exactly that).
+ *   - "1"/"yes"/"on" turn flair's /mcp handler ON while the component AS
+ *     stays OFF — fail-closed broken-on (every request 401s, no AS
+ *     advertised).
+ *   - garbage (e.g. "maybe") disables BOTH: the component deletes it, this
+ *     stays false, no /mcp handler exists — no data path (flair's own
+ *     discovery documents still serve whenever this flag is off, by design).
+ * If the component's vocabulary ever widens back to truthy-string, a garbage
+ * value would mount a live AS next to an unregistered /mcp — re-derive the
+ * garbage case (test/integration/mcp-oauth-boot-safety.test.ts) before
+ * relying on it, and NEVER let component `enabled` drive flair's handler
+ * registration directly without re-deriving that table.
  */
 export function mcpOAuthEnabled() {
     const raw = (process.env.FLAIR_MCP_OAUTH ?? "").trim().toLowerCase();

package/dist/resources/mcp-oauth.js

@@ -123,7 +123,12 @@ export async function registerMcpOAuthRoute(deps = {}) {
         return decide({
             mounted: false,
             status: "Not enabled",
-            reason: "Set FLAIR_MCP_OAUTH=1 (and an issuer) to serve MCP over HTTP.",
+            // "true" not "1": flair's flag accepts either, but the component's
+            // config-side read of the same var (config.yaml `mcp.enabled:
+            // ${FLAIR_MCP_OAUTH}`, flair#1152) accepts ONLY "true"/"false" — with
+            // "1" the /mcp route registers and every request 401s against a
+            // component that never mounted its AS.
+            reason: "Set FLAIR_MCP_OAUTH=true (and an issuer) to serve MCP over HTTP.",
         });
     }
     // Boot guard (flair#1021): fail loudly if the operator enabled the flag but