@tpsdev-ai/flair 0.28.0 → 0.30.0

package/dist/deploy.js

@@ -156,28 +156,38 @@ export function deriveVerifyResources(packageRoot) {
     names.sort();
     return names.length ? names : [FALLBACK_VERIFY_RESOURCE];
 }
+// flair#870: flair declares the BARE `harper` package name, so that is probed
+// first. `@harperfast/harper` is a permanent lockstep publish of the same
+// source under the legacy scoped name; it stays in the probe list because
+// `packageRoot` can be a staged install of an OLDER published flair (see
+// src/fabric-upgrade.ts) that declared the scoped name.
+const HARPER_PKG_NAMES = ["harper", "@harperfast/harper"];
 function resolveHarperBin(packageRoot) {
-    const local = join(packageRoot, "node_modules/@harperfast/harper/dist/bin/harper.js");
-    if (existsSync(local))
-        return local;
-    try {
-        const req = createRequire(join(packageRoot, "package.json"));
-        const mainPath = req.resolve("@harperfast/harper");
-        let dir = dirname(mainPath);
-        for (let i = 0; i < 6; i++) {
-            const candidate = join(dir, "dist/bin/harper.js");
-            if (existsSync(candidate))
-                return candidate;
-            const parent = dirname(dir);
-            if (parent === dir)
-                break;
-            dir = parent;
-        }
+    for (const pkg of HARPER_PKG_NAMES) {
+        const local = join(packageRoot, "node_modules", pkg, "dist/bin/harper.js");
+        if (existsSync(local))
+            return local;
     }
-    catch {
-        /* fall through */
+    for (const pkg of HARPER_PKG_NAMES) {
+        try {
+            const req = createRequire(join(packageRoot, "package.json"));
+            const mainPath = req.resolve(pkg);
+            let dir = dirname(mainPath);
+            for (let i = 0; i < 6; i++) {
+                const candidate = join(dir, "dist/bin/harper.js");
+                if (existsSync(candidate))
+                    return candidate;
+                const parent = dirname(dir);
+                if (parent === dir)
+                    break;
+                dir = parent;
+            }
+        }
+        catch {
+            /* try the next package name */
+        }
     }
-    throw new Error("Could not locate Harper CLI binary (@harperfast/harper). " +
+    throw new Error(`Could not locate Harper CLI binary (tried ${HARPER_PKG_NAMES.join(", ")}). ` +
         "Flair deploy requires Harper to be installed alongside Flair.");
 }
 // Pure arg-array builder — separated from spawnHarper so the timeout

package/dist/fabric-upgrade.js

@@ -9,9 +9,9 @@
  *   Upgrading a deployed Fabric Flair used to require, by hand:
  *     1. mkdir a fresh temp dir
  *     2. write a package.json that depends on @tpsdev-ai/flair@<version> AND
- *        carries an `overrides` block pinning @harperfast/harper to a fixed
+ *        carries an `overrides` block pinning harper to a fixed
  *        version — because the PUBLISHED flair declares an OLD Harper
- *        (@harperfast/harper@5.0.21 as of flair@0.14.0) whose component
+ *        (harper@5.0.21 as of flair@0.14.0) whose component
  *        packager (`packageComponent`) emits an EMPTY tarball when the package
  *        root lives under node_modules (the real npm-install scenario).
  *        See flair#513 — fixed in Harper >= 5.1.13.
@@ -31,7 +31,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { createRequire } from "node:module";
 /**
- * Minimum @harperfast/harper version whose component packager works when the
+ * Minimum harper version whose component packager works when the
  * package root is under node_modules (flair#513 — the empty-tarball fix landed
  * in 5.1.13). Anything below this MUST be overridden before a Fabric deploy.
  */
@@ -43,7 +43,18 @@ export const MIN_HARPER_VERSION = "5.1.13";
  */
 export const DEFAULT_HARPER_PIN = "5.1.14";
 const FLAIR_PKG = "@tpsdev-ai/flair";
-const HARPER_PKG = "@harperfast/harper";
+const HARPER_PKG = "harper";
+/**
+ * flair#870 renamed flair's Harper dependency from the scoped
+ * `@harperfast/harper` to the BARE `harper` name (permanent lockstep publishes
+ * of the same source; bare is upstream's primary public name).
+ *
+ * This module reads and rewrites the dependency graph of a PUBLISHED flair
+ * version, which may predate that rename — so every lookup here has to accept
+ * either name. The bare name is always preferred when both are present.
+ */
+const LEGACY_HARPER_PKG = "@harperfast/harper";
+const HARPER_PKG_NAMES = [HARPER_PKG, LEGACY_HARPER_PKG];
 /**
  * Parse "5.1.14" / "5.1.14-rc.1" / "v0.14.0" into [major, minor, patch],
  * ignoring any pre-release / build suffix for comparison. Returns null when the
@@ -76,7 +87,7 @@ export function semverGte(a, b) {
     return true; // equal
 }
 /**
- * Decide what (if any) @harperfast/harper override to bake into the temp
+ * Decide what (if any) harper override to bake into the temp
  * deployable's package.json.
  *
  *   - If flair already declares Harper >= MIN_HARPER_VERSION → no override
@@ -88,7 +99,7 @@ export function semverGte(a, b) {
  *     passed something too old.
  *
  * Pure — no I/O. The LOAD-BEARING bit is `overridden`: when true, the temp
- * package.json gets `overrides: { "@harperfast/harper": pin }`.
+ * package.json gets `overrides: { "harper": pin }`.
  */
 export function resolveHarperPin(declared, preferredPin) {
     if (declared && semverGte(declared, MIN_HARPER_VERSION)) {
@@ -120,6 +131,13 @@ export function resolveHarperPin(declared, preferredPin) {
  * @tpsdev-ai/flair@<version> and, when the Harper pin is an override, carries
  * the `overrides` block that forces npm to install the fix Harper under the
  * flair package's node_modules.
+ *
+ * The override is written under BOTH Harper package names (flair#870). Only
+ * flair versions OLDER than the rename ever need an override — MIN_HARPER_VERSION
+ * is 5.1.13 and every post-rename flair declares ≥ 5.1.22 — and those declare
+ * the scoped name, so dropping the legacy key would make the override a silent
+ * no-op exactly when it matters. Both are plain VERSION overrides, not `npm:`
+ * aliases; an override key that matches nothing in the tree is inert.
  */
 export function buildDeployablePackageJson(flairVersion, pin) {
     const pkg = {
@@ -131,7 +149,7 @@ export function buildDeployablePackageJson(flairVersion, pin) {
         },
     };
     if (pin.overridden) {
-        pkg.overrides = { [HARPER_PKG]: pin.pin };
+        pkg.overrides = Object.fromEntries(HARPER_PKG_NAMES.map((n) => [n, pin.pin]));
     }
     return pkg;
 }
@@ -156,7 +174,14 @@ async function defaultFetchDeclaredHarperVersion(flairVersion) {
     if (!res.ok)
         return null;
     const data = (await res.json());
-    return data.dependencies?.[HARPER_PKG] ?? null;
+    // Either package name (flair#870) — pre-rename flair versions declare the
+    // scoped one, and those are precisely the versions that may need an override.
+    for (const name of HARPER_PKG_NAMES) {
+        const declared = data.dependencies?.[name];
+        if (declared)
+            return declared;
+    }
+    return null;
 }
 function defaultNpmInstall(dir) {
     // No package spec on argv — npm reads dependencies + overrides from the
@@ -205,13 +230,22 @@ async function defaultFetchDeployedVersion(opts) {
         return null;
     }
 }
-/** Resolve the @harperfast/harper bin that npm installed under the staged flair. */
+/**
+ * Resolve the harper bin that npm installed under the staged flair.
+ *
+ * Probes both Harper package names (flair#870): the staged flair may be a
+ * pre-rename published version whose Harper landed under `@harperfast/harper`.
+ */
 export function resolveStagedHarperVersion(stagingDir) {
-    const harperPkgJson = join(stagingDir, "node_modules", FLAIR_PKG, "node_modules", HARPER_PKG, "package.json");
-    // npm dedupes: with an override the fixed Harper may hoist to the staging
-    // root rather than nest under flair. Check both.
-    const hoisted = join(stagingDir, "node_modules", HARPER_PKG, "package.json");
-    for (const candidate of [harperPkgJson, hoisted]) {
+    const candidates = [];
+    for (const name of HARPER_PKG_NAMES) {
+        // Nested under the staged flair…
+        candidates.push(join(stagingDir, "node_modules", FLAIR_PKG, "node_modules", name, "package.json"));
+        // …or hoisted: npm dedupes, and with an override the fixed Harper may sit
+        // at the staging root rather than nest under flair. Check both.
+        candidates.push(join(stagingDir, "node_modules", name, "package.json"));
+    }
+    for (const candidate of candidates) {
         if (existsSync(candidate)) {
             try {
                 const pkg = JSON.parse(readFileSync(candidate, "utf8"));
@@ -224,16 +258,20 @@ export function resolveStagedHarperVersion(stagingDir) {
         }
     }
     // Last resort: resolve through the staged flair's module graph.
-    try {
-        const flairPkg = join(stagingDir, "node_modules", FLAIR_PKG, "package.json");
-        const req = createRequire(flairPkg);
-        const resolved = req.resolve(`${HARPER_PKG}/package.json`);
-        const pkg = JSON.parse(readFileSync(resolved, "utf8"));
-        return typeof pkg.version === "string" ? pkg.version : null;
-    }
-    catch {
-        return null;
+    const flairPkg = join(stagingDir, "node_modules", FLAIR_PKG, "package.json");
+    for (const name of HARPER_PKG_NAMES) {
+        try {
+            const req = createRequire(flairPkg);
+            const resolved = req.resolve(`${name}/package.json`);
+            const pkg = JSON.parse(readFileSync(resolved, "utf8"));
+            if (typeof pkg.version === "string")
+                return pkg.version;
+        }
+        catch {
+            /* try the next package name */
+        }
     }
+    return null;
 }
 /** Locate the staged @tpsdev-ai/flair package root (the deploy() packageRoot). */
 export function resolveStagedFlairRoot(stagingDir) {

package/dist/fleet-verify.js

@@ -13,11 +13,11 @@
  * ── What "peer" means here — read before trusting a green sweep ──────────
  * Harper Fabric's OWN cluster-replication peers (the physical nodes a
  * component gets replicated to by `harper deploy`) are NOT enumerable
- * through any operation in the OSS @harperfast/harper build this repo
+ * through any operation in the OSS harper build this repo
  * depends on. `cluster_status` — the operation that would answer "what
  * nodes are in this cluster and are they in sync" — is explicitly called
- * out as harper-pro-only in Harper's own source (node_modules/@harperfast/
- * harper/components/mcp/tools/schemas/operationDescriptions.ts: "Out-of-core
+ * out as harper-pro-only in Harper's own source (node_modules/harper/
+ * components/mcp/tools/schemas/operationDescriptions.ts: "Out-of-core
  * operations (e.g. harper-pro's cluster_status) cannot have entries here").
  * There is no "list this cluster's replication nodes" call available to this
  * CLI, on the origin or anywhere else — direct AND via-origin cluster

package/dist/lib/mcp-enable.js

@@ -70,9 +70,9 @@
  *
  * ── Ground truth used to design the remote "existing ops paths" step ────────
  * Verified against the ACTUALLY INSTALLED packages, not assumed:
- *   - `@harperfast/harper`'s Operations API has a genuine `set_configuration`
+ *   - `harper`'s Operations API has a genuine `set_configuration`
  *     operation (writes harperdb-config.yaml for all workers, requires a
- *     restart to take effect — node_modules/@harperfast/harper/dist/config/
+ *     restart to take effect — node_modules/harper/dist/config/
  *     configUtils.js's `setConfiguration`) and a genuine `restart` operation
  *     (whole-process restart — see .../components/mcp/tools/schemas/
  *     operationDescriptions.js's operation catalog). Both are called the

package/dist/rem/runner.js

@@ -20,8 +20,8 @@
  *   - Steps 1, 2 shipped in slice-1 PR-1 (#414).
  *   - Step 3 (maintenance) shipped in a prior slice-2 PR — fills
  *     `archived`/`expired` in the audit row.
- *   - Step 4: per specs/FLAIR-NIGHTLY-REM-SLICE-2-DISTILLATION.md § 3B,
- *     "Deferred from parent § 4 step 4" — trust tiers aren't derivable yet
+ *   - Step 4: per §3B (issue #707), "Deferred from parent § 4 step 4" —
+ *     trust tiers aren't derivable yet
  *     (that's the emergent-trust arc). The input filter stays as today (own
  *     agent, non-archived, non-permanent, scope window); the safety net for
  *     un-tiered input is structural — candidates are staged, never

package/dist/rem/scheduler.js

@@ -16,7 +16,7 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync, chmodSync, rmSync } from "node:fs";
 import { resolve, dirname } from "node:path";
 import { homedir, platform } from "node:os";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 export const SHIM_PATH_DEFAULT = resolve(homedir(), ".flair", "bin", "flair-rem-nightly");
 export const LAUNCHD_PLIST_PATH = resolve(homedir(), "Library", "LaunchAgents", "dev.flair.rem.nightly.plist");
@@ -102,10 +102,16 @@ function writeFileWithDir(path, contents, mode = 0o600) {
 // 30s ceiling on launchctl/systemctl invocations so a hung service manager
 // can't block the CLI indefinitely. Sherlock #415 follow-up.
 const SPAWN_TIMEOUT_MS = 30_000;
-function spawnReport(cmd) {
+// Status-check spawns (launchctl print / systemctl is-active) return
+// near-instantly when the service manager is reachable, and fail fast (no
+// hang) when it isn't (e.g. "Failed to connect to bus"). A short ceiling
+// keeps `flair rem nightly status` and the Health endpoint responsive even
+// when the query is inconclusive.
+const STATUS_CHECK_TIMEOUT_MS = 5_000;
+function spawnReport(cmd, timeoutMs = SPAWN_TIMEOUT_MS) {
     const r = spawnSync(cmd[0], cmd.slice(1), {
         encoding: "buffer",
-        timeout: SPAWN_TIMEOUT_MS,
+        timeout: timeoutMs,
     });
     return {
         code: r.status,
@@ -113,6 +119,195 @@ function spawnReport(cmd) {
         stderr: r.stderr?.toString("utf-8") ?? "",
     };
 }
+/**
+ * Command to genuinely query the platform scheduler's active/loaded state
+ * for a given install (as opposed to the shape of `loadCommand`, which
+ * *installs* it). Shared by the sync and async active-state checks below so
+ * the two can't drift.
+ */
+function activeCheckCommand(plat) {
+    if (plat === "darwin") {
+        return ["launchctl", "print", `gui/${process.getuid?.() ?? ""}/dev.flair.rem.nightly`];
+    }
+    return ["systemctl", "--user", "is-active", "flair-rem-nightly.timer"];
+}
+/**
+ * Interprets the result of `activeCheckCommand()`. Shared by the sync
+ * (CLI) and async (server) callers.
+ *
+ * - true  — the service manager confirms the job is loaded/active.
+ * - false — confirmed NOT active. This includes the "no session bus" case
+ *   (flair#850): when `systemctl --user` can't reach a bus, it fails
+ *   before printing a status word ("Failed to connect to bus: No medium
+ *   found") — but nothing CAN be running without a bus, so `false` is the
+ *   honest answer, not "unknown".
+ * - null  — genuinely inconclusive (the command itself couldn't run at
+ *   all — e.g. the binary is missing — with no output to interpret).
+ */
+export function interpretActiveResult(plat, code, stdout, stderr) {
+    const noOutput = !stdout.trim() && !stderr.trim();
+    if (plat === "darwin") {
+        if (code === 0)
+            return true;
+        if (code === null && noOutput)
+            return null; // spawn itself failed — inconclusive
+        return false; // launchctl ran and reported not-loaded
+    }
+    const out = stdout.trim();
+    if (out === "active" || out === "activating")
+        return true;
+    if (out === "inactive" || out === "failed" || out === "unknown")
+        return false;
+    if (code === null && noOutput)
+        return null; // spawn itself failed — inconclusive
+    return false; // covers the no-bus case: empty stdout, nonzero/failed exit
+}
+/**
+ * Synchronous active-state check for CLI use (`flair rem nightly status`).
+ * Blocking is fine here — this is a one-shot process and the caller wants
+ * the answer before printing anything.
+ */
+function queryActiveState(plat) {
+    const [cmd, ...args] = activeCheckCommand(plat);
+    const r = spawnReport([cmd, ...args], STATUS_CHECK_TIMEOUT_MS);
+    return interpretActiveResult(plat, r.code, r.stdout, r.stderr);
+}
+/**
+ * Async, non-blocking equivalent for server contexts (the Health endpoint)
+ * where a synchronous subprocess would stall the request-handling thread.
+ * Same semantics as `queryActiveState()`.
+ */
+export async function queryActiveStateAsync(plat, timeoutMs = STATUS_CHECK_TIMEOUT_MS) {
+    const [cmd, ...args] = activeCheckCommand(plat);
+    return new Promise((resolvePromise) => {
+        let settled = false;
+        let child;
+        const finish = (result) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolvePromise(result);
+        };
+        const timer = setTimeout(() => {
+            try {
+                child?.kill("SIGKILL");
+            }
+            catch { /* best-effort */ }
+            finish(null);
+        }, timeoutMs);
+        try {
+            child = spawn(cmd, args, { stdio: ["ignore", "pipe", "pipe"] });
+        }
+        catch {
+            finish(null);
+            return;
+        }
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (d) => { stdout += d.toString("utf-8"); });
+        child.stderr?.on("data", (d) => { stderr += d.toString("utf-8"); });
+        child.on("error", () => finish(null));
+        child.on("close", (code) => finish(interpretActiveResult(plat, code, stdout, stderr)));
+    });
+}
+/**
+ * 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.
+ */
+export function describeLoadFailure(plat, loadResult) {
+    const stderr = loadResult.stderr || "";
+    if (plat === "linux" && /failed to connect to bus/i.test(stderr)) {
+        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 `flair rem nightly enable`.");
+    }
+    return null;
+}
+/**
+ * Formats the `flair rem nightly enable` report from an `EnableResult`.
+ * Pulled out of the CLI action so the success-vs-failure decision (flair#850:
+ * do not print a success headline before activation is known to have
+ * 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`.
+ */
+export function formatEnableReport(r, input) {
+    const { hour, minute, agentId, flairUrl } = input;
+    const scheduleTime = `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+    const activationFailed = !!r.loadResult && r.loadResult.code !== 0;
+    if (activationFailed) {
+        const lr = r.loadResult;
+        const lines = [
+            `⚠️  REM nightly scheduler files written but NOT activated (${r.platform})`,
+            `   Schedule:    ${scheduleTime} local time — NOT scheduled (see below)`,
+            `   Scheduler:   ${r.schedulerPath}`,
+            `   Shim:        ${r.shimPath}`,
+            `   Agent:       ${agentId}`,
+            `   Flair URL:   ${flairUrl}`,
+            `   Activation:  ${r.loadCommand.join(" ")} → code ${lr.code}`,
+        ];
+        if (lr.stderr)
+            lines.push(`     stderr: ${lr.stderr.trim()}`);
+        const remedy = describeLoadFailure(r.platform, lr);
+        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`);
+        return { lines, ok: false };
+    }
+    const lines = [
+        `✅ REM nightly scheduler enabled (${r.platform})`,
+        `   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`);
+    }
+    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\`.`);
+    return { lines, ok: true };
+}
+/**
+ * Formats the `flair rem nightly status` report from a `SchedulerStatus`.
+ * Extracted for the same testability reason as `formatEnableReport()`
+ * (flair#850): status must report genuine active state, not file presence.
+ */
+export function formatStatusReport(s) {
+    const activeTxt = s.active === true ? "yes" : s.active === false ? "no" : "unknown";
+    const lines = [
+        `REM nightly scheduler (${s.platform}):`,
+        `  Active:      ${activeTxt}`,
+        `  Installed:   ${s.installed ? "yes" : "no"}`,
+        `  Scheduler:   ${s.schedulerPath}`,
+        `  Shim:        ${s.shimPath}${s.shimExists ? "" : " (missing)"}`,
+    ];
+    if (!s.installed) {
+        lines.push("");
+        lines.push(`Enable with: flair rem nightly enable --agent <id> [--at HH:MM]`);
+    }
+    else if (s.active === false) {
+        lines.push("");
+        lines.push(`Files are written but nothing is scheduled — the job is not loaded/active.`);
+        lines.push(`Re-run: flair rem nightly enable --agent <id> [--at HH:MM]`);
+    }
+    // Status is informational — it does not itself signal process failure,
+    // consistent with the pre-existing "not installed" case never exiting
+    // nonzero. `ok` here only reflects whether the headline claims success.
+    return { lines, ok: s.active !== false };
+}
 /**
  * Installs the platform-native scheduler entry and the shim script.
  *
@@ -215,26 +410,40 @@ export function disableScheduler(opts = {}) {
     return { platform: plat, removed, unloadCommand, unloadResult };
 }
 /**
- * Reports whether the scheduler is installed. Filesystem-only — does not
- * shell out to launchctl/systemctl to query active state. The Health
- * endpoint already does that via existence checks; same approach here.
+ * Reports whether the scheduler is installed AND whether it is genuinely
+ * active. File presence alone proves the templates were written — it does
+ * NOT prove `launchctl`/`systemctl` successfully loaded the job (flair#850).
  */
 export function schedulerStatus(opts = {}) {
     const plat = detectPlatform(opts.platformOverride);
+    const shimPath = opts.shimPathOverride ?? SHIM_PATH_DEFAULT;
+    let schedulerPath;
+    let installed;
     if (plat === "darwin") {
-        return {
-            platform: plat,
-            installed: existsSync(LAUNCHD_PLIST_PATH),
-            schedulerPath: LAUNCHD_PLIST_PATH,
-            shimPath: SHIM_PATH_DEFAULT,
-            shimExists: existsSync(SHIM_PATH_DEFAULT),
-        };
+        schedulerPath = opts.launchdPlistOverride ?? LAUNCHD_PLIST_PATH;
+        installed = existsSync(schedulerPath);
+    }
+    else {
+        schedulerPath = opts.systemdTimerOverride ?? SYSTEMD_TIMER_PATH;
+        const servicePath = opts.systemdServiceOverride ?? SYSTEMD_SERVICE_PATH;
+        installed = existsSync(schedulerPath) && existsSync(servicePath);
+    }
+    let active;
+    if (!installed) {
+        active = false; // nothing written — definitely nothing active
+    }
+    else if (opts.skipActiveCheck) {
+        active = null; // caller opted out — unknown, not a claim either way
+    }
+    else {
+        active = queryActiveState(plat);
     }
     return {
         platform: plat,
-        installed: existsSync(SYSTEMD_TIMER_PATH) && existsSync(SYSTEMD_SERVICE_PATH),
-        schedulerPath: SYSTEMD_TIMER_PATH,
-        shimPath: SHIM_PATH_DEFAULT,
-        shimExists: existsSync(SHIM_PATH_DEFAULT),
+        installed,
+        active,
+        schedulerPath,
+        shimPath,
+        shimExists: existsSync(shimPath),
     };
 }

package/dist/resources/A2AAdapter.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { access, readFile, readdir } from "node:fs/promises";
 import { constants } from "node:fs";
 import { basename, extname, join } from "node:path";

package/dist/resources/Admin.js

@@ -1,4 +1,4 @@
-import { Resource } from "@harperfast/harper";
+import { Resource } from "harper";
 import { allowAdmin } from "./agent-auth.js";
 /**
  * GET /Admin — friendly redirect to /AdminDashboard.

package/dist/resources/AdminConnectors.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { layout, htmlResponse, esc } from "./admin-layout.js";
 import { allowAdmin } from "./agent-auth.js";
 /**

package/dist/resources/AdminDashboard.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { layout, htmlResponse } from "./admin-layout.js";
 import { allowAdmin } from "./agent-auth.js";
 /**

package/dist/resources/AdminIdp.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { layout, htmlResponse, esc } from "./admin-layout.js";
 import { allowAdmin } from "./agent-auth.js";
 /**

package/dist/resources/AdminInstance.js

@@ -1,4 +1,4 @@
-import { Resource } from "@harperfast/harper";
+import { Resource } from "harper";
 import { layout, htmlResponse } from "./admin-layout.js";
 import { existsSync, readFileSync } from "node:fs";
 import { join, dirname } from "node:path";

package/dist/resources/AdminMemory.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { layout, htmlResponse, esc } from "./admin-layout.js";
 import { allowAdmin } from "./agent-auth.js";
 /**

package/dist/resources/AdminPrincipals.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { layout, htmlResponse, esc } from "./admin-layout.js";
 import { allowAdmin } from "./agent-auth.js";
 /**

package/dist/resources/Agent.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { resolveAgentAuth, allowVerified, allowAdmin } from "./agent-auth.js";
 import { localInstanceId } from "./instance-identity.js";
 /**

package/dist/resources/AgentCard.js

@@ -1,4 +1,4 @@
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { selectPublicDescription, selectPublicSkills } from "./agentcard-fields.js";
 export class AgentCard extends Resource {
     // Public discovery metadata (per A2A spec, agent cards are intentionally

package/dist/resources/AgentSeed.js

@@ -16,7 +16,7 @@
  *
  * Auth: admin only.
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { isAdmin, allowAdmin } from "./agent-auth.js";
 const DEFAULT_SOUL_KEYS = (agentId, displayName, role, now) => ({
     name: displayName,

package/dist/resources/AttentionQuery.js

@@ -75,7 +75,7 @@
  * validated single-entity + bounded-window condition (WorkspaceState), OR
  * goes through the source's own content-gated resource (Presence).
  */
-import { Resource, databases } from "@harperfast/harper";
+import { Resource, databases } from "harper";
 import { resolveAgentAuth, allowVerified } from "./agent-auth.js";
 import { isValidEntity } from "./entity-vocab.js";
 import { resolveReadScope } from "./memory-read-scope.js";

package/dist/resources/Credential.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { resolveAgentAuth, allowVerified } from "./agent-auth.js";
 import { checkRateLimit, rateLimitResponse } from "./rate-limiter.js";
 /**

package/dist/resources/Federation.js

@@ -1,4 +1,4 @@
-import { Resource, databases, server } from "@harperfast/harper";
+import { Resource, databases, server } from "harper";
 import { randomBytes } from "node:crypto";
 import nacl from "tweetnacl";
 import { allowAdmin } from "./agent-auth.js";

package/dist/resources/Instance.js

@@ -1,4 +1,4 @@
-import { databases } from "@harperfast/harper";
+import { databases } from "harper";
 import { allowVerified, allowAdmin } from "./agent-auth.js";
 /**
  * Instance is read-only reference data for agents (flair_agent grant: read only).