diff --git a/__tests__/hooks/configure-wizard.test.ts b/__tests__/hooks/configure-wizard.test.ts
index 885eeaadf..b78bc5981 100644
--- a/__tests__/hooks/configure-wizard.test.ts
+++ b/__tests__/hooks/configure-wizard.test.ts
@@ -231,16 +231,21 @@ const FOURTEEN_ENABLED = [
 // touches the developer's real config.
 let fileHome: string;
 let realHome: string | undefined;
+let realUserProfile: string | undefined;
 /** Must match the path built inside the hooks-config mock factory above. */
 const WIZARD_TEST_CONFIG_DIR = resolve(tmpdir(), `fpai-wizard-cfg-${process.pid}`);
 beforeAll(() => {
   realHome = process.env.HOME;
+  realUserProfile = process.env.USERPROFILE;
   fileHome = mkdtempSync(resolve(tmpdir(), "fpai-cfg-"));
   process.env.HOME = fileHome;
+  process.env.USERPROFILE = fileHome;
 });
 afterAll(() => {
   if (realHome === undefined) delete process.env.HOME;
   else process.env.HOME = realHome;
+  if (realUserProfile === undefined) delete process.env.USERPROFILE;
+  else process.env.USERPROFILE = realUserProfile;
   try {
     rmSync(fileHome, { recursive: true, force: true });
   } catch {
@@ -599,18 +604,23 @@ describe("configure-wizard orchestration", () => {
 
 describe("first-run redirect", () => {
   let origHome: string | undefined;
+  let origUserProfile: string | undefined;
   let tmp: string;
 
   beforeEach(() => {
     origHome = process.env.HOME;
+    origUserProfile = process.env.USERPROFILE;
     delete process.env.FAILPROOFAI_NO_FIRST_RUN;
     tmp = mkdtempSync(resolve(tmpdir(), "fpai-firstrun-"));
     process.env.HOME = tmp;
+    process.env.USERPROFILE = tmp;
   });
 
   afterEach(() => {
     if (origHome === undefined) delete process.env.HOME;
     else process.env.HOME = origHome;
+    if (origUserProfile === undefined) delete process.env.USERPROFILE;
+    else process.env.USERPROFILE = origUserProfile;
     try {
       rmSync(tmp, { recursive: true, force: true });
     } catch {
@@ -1325,6 +1335,67 @@ describe("configure-wizard daemon integration", () => {
     }).join("\n");
     expect(connected).toContain("transcripts");
   });
+
+  // ── --no-daemon ───────────────────────────────────────────────────────────
+
+  it("--no-daemon: skips installDaemonService and primeElevation, applies successfully", async () => {
+    // Container / rootless-CI path: the caller knows no service manager is
+    // available and opts out of daemon installation. Hooks still write and
+    // policies still enforce in-process.
+    vi.mocked(isDaemonSupportedPlatform).mockReturnValue(true);
+    vi.mocked(daemonServiceStatus).mockReturnValue("not-installed");
+    drive(HAPPY);
+
+    const result = await runConfigureWizard(ttyIO(), { noDaemon: true });
+
+    expect(result.applied).toBe(true);
+    expect(installDaemonService).not.toHaveBeenCalled();
+    expect(primeElevation).not.toHaveBeenCalled();
+    expect(installHooks).toHaveBeenCalledTimes(1);
+  });
+
+  it("--no-daemon: sets daemonConfigured=false so hooks enforce in-process", async () => {
+    vi.mocked(isDaemonSupportedPlatform).mockReturnValue(true);
+    vi.mocked(daemonServiceStatus).mockReturnValue("not-installed");
+    drive(HAPPY);
+
+    const result = await runConfigureWizard(ttyIO(), { noDaemon: true });
+
+    expect(result.applied).toBe(true);
+    expect(result.daemonInstalled).toBeFalsy();
+    expect(readGlobalConfig().daemonConfigured).toBeUndefined();
+    expect(readFpConfig().daemon.configured).toBe(false);
+  });
+
+  it("--no-daemon: leaves an already-running daemon untouched", async () => {
+    // \"don't install\" is not \"tear down what is there\": a machine that
+    // already has failproofaid should keep it. Only the INSTALL step is
+    // skipped, not the detection of a healthy existing service.
+    vi.mocked(isDaemonSupportedPlatform).mockReturnValue(true);
+    vi.mocked(daemonServiceStatus).mockReturnValue("running");
+    vi.mocked(probeDaemonEndToEnd).mockResolvedValue(true);
+    drive(HAPPY);
+
+    const result = await runConfigureWizard(ttyIO(), { noDaemon: true });
+
+    expect(result.applied).toBe(true);
+    // Already-running daemon: daemonInstalled should be true (it was already there)
+    expect(result.daemonInstalled).toBe(true);
+    expect(installDaemonService).not.toHaveBeenCalled();
+    expect(uninstallDaemonService).not.toHaveBeenCalled();
+  });
+
+  it("--no-daemon: needs_root abort text mentions --no-daemon as an alternative", async () => {
+    vi.mocked(isDaemonSupportedPlatform).mockReturnValue(true);
+    vi.mocked(primeElevation).mockReturnValue(false);
+    const stdout = mkTtyStdout();
+    drive(HAPPY);
+
+    await runConfigureWizard({ stdin: mkTtyStdin(), stdout });
+
+    const written = vi.mocked(stdout.write).mock.calls.map((c) => String(c[0])).join("");
+    expect(written).toContain("--no-daemon");
+  });
 });
 describe("scope", () => {
   // The wizard can no longer produce "project" or "both": scope was a fork, and
diff --git a/bin/failproofai.mjs b/bin/failproofai.mjs
index 9367cd3b9..b33a146d8 100755
--- a/bin/failproofai.mjs
+++ b/bin/failproofai.mjs
@@ -2232,6 +2232,7 @@ async function runCli() {
             entries: [
               ["(bare)", "Guided setup: agents, daemon, cloud"],
               ["--token <key>", "Set up and connect to Cloud, asking nothing"],
+              ["--no-daemon", "Skip daemon install; enforce in-process instead"],
               ["--status", "Connection, daemon version and pause state"],
               ["--pause [<time>]", "Pause enforcement for one session"],
               ["--resume [--all]", "End a pause early"],
@@ -2247,6 +2248,10 @@ async function runCli() {
               "Cloud. It chooses NO policies — take some with:",
               "",
               "    failproofai policies add <owner>/<repo>",
+              "",
+              "Use --no-daemon on containers or any environment where a system service",
+              "cannot be installed. Hooks enforce in-process; the background audit",
+              "schedule is not available, but policies still run on every tool call.",
             ],
           },
           {
@@ -2492,6 +2497,7 @@ async function runCli() {
         machineId: valueFor("--machine-id"),
         machineLabel: valueFor("--machine-label"),
         noTranscripts: args.includes("--no-transcripts"),
+        noDaemon: args.includes("--no-daemon"),
       },
     );
     await warnTokenOnArgv();
diff --git a/scripts/launch.ts b/scripts/launch.ts
index 772285c8c..9d5a091cb 100644
--- a/scripts/launch.ts
+++ b/scripts/launch.ts
@@ -91,12 +91,26 @@ export function launch(mode: "dev" | "start"): void {
     }
     cmdArgs = [serverJsPath];
   } else {
-    cmd = "bunx";
-    // `next dev` with no -H listens on every interface too, so dev gets the same
-    // default. Skipped when the caller already passed one through, so an
-    // explicit -H in remainingArgs still wins.
-    const hasHostFlag = remainingArgs.some((a) => a === "-H" || a === "--hostname" || a.startsWith("--hostname="));
-    cmdArgs = ["--bun", "next", "dev", ...(hasHostFlag ? [] : ["-H", bindHost]), ...remainingArgs];
+    // Use the local next binary directly to avoid a Windows-specific Bun bug
+    // where `bunx --bun next dev` misinterprets the absolute path of the local
+    // `next` package (e.g. D:/Projects/...) as a scoped npm package name
+    // (@D:/Projects/...) and tries to git-clone it.
+    const isWindows = process.platform === "win32";
+    if (isWindows) {
+      cmd = resolve(dirname(realpathSync(fileURLToPath(import.meta.url))), "../node_modules/.bin/next.cmd");
+      // `next dev` with no -H listens on every interface too, so dev gets the same
+      // default. Skipped when the caller already passed one through, so an
+      // explicit -H in remainingArgs still wins.
+      const hasHostFlag = remainingArgs.some((a) => a === "-H" || a === "--hostname" || a.startsWith("--hostname="));
+      cmdArgs = ["dev", ...(hasHostFlag ? [] : ["-H", bindHost]), ...remainingArgs];
+    } else {
+      cmd = "bunx";
+      // `next dev` with no -H listens on every interface too, so dev gets the same
+      // default. Skipped when the caller already passed one through, so an
+      // explicit -H in remainingArgs still wins.
+      const hasHostFlag = remainingArgs.some((a) => a === "-H" || a === "--hostname" || a.startsWith("--hostname="));
+      cmdArgs = ["--bun", "next", "dev", ...(hasHostFlag ? [] : ["-H", bindHost]), ...remainingArgs];
+    }
   }
 
   // In `start` (the shipped standalone server) we pipe + filter the child's
diff --git a/src/hooks/configure-wizard.ts b/src/hooks/configure-wizard.ts
index 2d1c4fd44..2b74487e6 100644
--- a/src/hooks/configure-wizard.ts
+++ b/src/hooks/configure-wizard.ts
@@ -134,6 +134,17 @@ export interface WizardAnswers {
   machineLabel?: string;
   /** Record decisions only, no session transcripts. */
   noTranscripts?: boolean;
+  /**
+   * Skip daemon installation entirely.
+   *
+   * Containers, rootless environments and CI machines that cannot install a
+   * system service use this. Hooks are wired and policies enforced in-process;
+   * `daemonConfigured` is explicitly set to false so the hook path stays in
+   * in-process mode rather than failing closed against a socket nothing listens
+   * on. `--no-daemon` is not allowed on platforms where the daemon is
+   * unsupported (Windows) — those abort before this flag is ever read.
+   */
+  noDaemon?: boolean;
 }
 
 /**
@@ -784,6 +795,12 @@ export async function runConfigureWizard(
   // single prompt is asked: completing setup anyway used to leave e.g. a
   // Windows machine reading as configured while enforcing in-process with no
   // fail-closed guarantee, which is worse than not being set up at all.
+  //
+  // --no-daemon is NOT an escape hatch for unsupported platforms: the platform
+  // gate is a hard invariant about what the binary can do, not about which
+  // steps the caller wants to run. A container user on Linux who cannot install
+  // a service is the target; a Windows host where failproofaid simply does not
+  // exist is a different category and keeps aborting.
   if (!isDaemonSupportedPlatform()) {
     stdout.write(
       `failproofai requires failproofaid, its background policy daemon, which runs on\n` +
@@ -872,7 +889,13 @@ export async function runConfigureWizard(
    * unloads before it writes.
    */
   const daemonBroken = daemonState === "running" && daemonSkew === null && !daemonAnswers;
-  let daemonWanted = daemonSupported && !daemonAlreadyRunning;
+  // --no-daemon: the caller has opted out of service installation for this
+  // machine (containers, rootless CI, privilege-less environments). We skip
+  // every daemon step and leave daemonConfigured at false so the hook path
+  // stays in in-process mode. An already-running daemon is left untouched —
+  // "don't install" is not "tear down what is there".
+  const skipDaemon = answers.noDaemon === true;
+  let daemonWanted = daemonSupported && !daemonAlreadyRunning && !skipDaemon;
   // A healthy daemon can still be running a service definition written before
   // FAILPROOFAI_CLI_CMD existed, and nothing else on the machine will ever
   // rewrite it: upgrading the npm package does not touch /etc/systemd/system.
@@ -880,7 +903,14 @@ export async function runConfigureWizard(
   // be brought up to date, so it is the moment to do it.
   let daemonUnitStale = daemonAlreadyRunning && daemonServiceNeedsUpgrade();
 
-  if (daemonWanted) {
+  if (skipDaemon && !daemonAlreadyRunning) {
+    // --no-daemon acknowledged: no service will be installed. Hooks will
+    // enforce in-process. Cloud-managed policies still work — the daemon
+    // is only needed for the background audit schedule and fail-closed mode.
+    stdout.write(
+      "Skipping daemon installation (--no-daemon). Hooks will enforce in-process.\n\n",
+    );
+  } else if (daemonWanted) {
     // Say what is about to happen. Nothing else.
     //
     // This block explained the warm-worker architecture to somebody who is
@@ -910,6 +940,7 @@ export async function runConfigureWizard(
       stdout.write(
         "\nCould not get root, so setup stopped before changing anything.\n\n" +
           "  Re-run once you can use sudo:   failproofai config\n" +
+          `  Or skip daemon install:         failproofai config --no-daemon\n` +
           `  Check what it needs:            ${daemonStatusCommand() ?? "n/a"}\n\n`,
       );
       void emit("configure_aborted", { reason: "needs_root" });
@@ -1453,6 +1484,12 @@ export async function runConfigureWizard(
     // longer referenced by anything. Keeps the previous version for an
     // offline rollback.
     pruneOldDaemonBinaries();
+  } else if (skipDaemon) {
+    // Explicitly mark daemon as NOT configured so the hook path stays in
+    // in-process mode rather than reading a stale daemonConfigured: true from
+    // a previous install and failing closed against a socket nobody is
+    // listening on.
+    setDaemonConfigured(false);
   }
 
   // Telemetry runs concurrently with the install (never rejects, 5s-bounded) so
diff --git a/src/hooks/onboarding-attempt.ts b/src/hooks/onboarding-attempt.ts
index 9b724517a..2f6eb601f 100644
--- a/src/hooks/onboarding-attempt.ts
+++ b/src/hooks/onboarding-attempt.ts
@@ -185,7 +185,9 @@ export function attemptHintLines(attempt: OnboardingAttempt): string[] {
   const action =
     attempt.reason === "unsupported_platform"
       ? "Check for a failproofai update — this platform may be supported by a newer release."
-      : "Run `failproofai config` when you are ready.";
+      : attempt.reason === "needs_root"
+        ? "Run `failproofai config` when you can use sudo, or `failproofai config --no-daemon` to skip the service."
+        : "Run `failproofai config` when you are ready.";
   return [
     ``,
     `[failproofai] Setup is not finished — ${detail}.`,