layero 0.7.5 → 0.8.1

package/README.md

@@ -176,10 +176,16 @@ Event types emitted on stdout:
 {"event":"deploy_started","deploy_id":"…"}
 {"event":"build_log","line":"…","stream":"…"}
 {"event":"stage","name":"…"}
-{"event":"ready","url":"…","deploy_id":"…"}
+{"event":"ready","url":"…","preview_url":"…","dashboard_url":"…","edge_ready":false,"edge_eta_seconds":N,"deploy_id":"…"}
+{"event":"promoted","url":"…","deploy_id":"…"}
 {"event":"error","code":"…","next_action":"…","message":"…"}
 ```
 
+On `ready`, `url` is the **live public site** (the apex — CLI uploads
+auto-promote to it), `preview_url` is reachable immediately while the apex CDN
+edge warms (`edge_ready=false`), and `dashboard_url` is the management page (not
+the site). Not logged in? `deploy` starts the device-flow itself (`auth_required`).
+
 Errors carry a stable `code` (e.g. `not_logged_in`, `invalid_type`,
 `project_not_found`, `cli_deploys_disabled`) and a `next_action` hint so
 your agent can react without parsing prose.

package/dist/agent.js

@@ -143,7 +143,24 @@ function renderHuman(event) {
             process.stdout.write(`${event.line}\n`);
             break;
         case "ready":
-            process.stdout.write(`✓ Live at ${event.url}\n`);
+            if (event.edge_ready === false) {
+                // Built & published, but the CDN edge for the apex is still
+                // propagating (first deploy of a new hostname can take a few
+                // minutes on YC CDN). The preview host is reachable immediately.
+                const eta = typeof event.edge_eta_seconds === "number" && event.edge_eta_seconds > 0
+                    ? ` (edge propagating, ~${event.edge_eta_seconds}s)`
+                    : " (edge propagating)";
+                process.stdout.write(`✓ Built. Live at ${event.url}${eta}\n`);
+                if (event.preview_url) {
+                    process.stdout.write(`  Reachable now: ${event.preview_url}\n`);
+                }
+            }
+            else {
+                process.stdout.write(`✓ Live at ${event.url}\n`);
+            }
+            break;
+        case "promoted":
+            process.stdout.write(`✓ Published apex → ${event.url}\n`);
             break;
         case "error":
             process.stderr.write(`Error: ${event.code}\n`);

package/dist/api.js

@@ -77,6 +77,12 @@ export class ApiClient {
     triggerDeploy(projectId, input) {
         return this.request("POST", `/projects/${projectId}/deploy`, input);
     }
+    // Edge/URL readiness for an environment. Used after a deploy reaches
+    // `ready` to report the real public URL + a reachable preview link
+    // instead of the management dashboard.
+    probeEnvironment(environmentId) {
+        return this.request("GET", `/environments/${environmentId}/probe`);
+    }
     pollLogs(deployId, afterId) {
         return this.request("GET", `/deploys/${deployId}/logs?after_id=${afterId}`);
     }

package/dist/auth.js

@@ -0,0 +1,69 @@
+// Shared device-auth flow.
+//
+// Used by `layero login` (always) and by `layero deploy` when no token is
+// saved yet (B5/I4 — the documented happy path is `deploy` kicking off the
+// device login inline and polling, rather than erroring out to a separate
+// `login` command).
+import chalk from "chalk";
+import open from "open";
+import { saveConfig } from "./config.js";
+import { ApiClient } from "./api.js";
+import { LayeroError, detectMode, emit } from "./agent.js";
+const MAX_WAIT_MS = 15 * 60 * 1000;
+/**
+ * Run the browser device-auth flow against `cfg`, persist the resulting
+ * token, and return the updated config. Emits `auth_required` (so agents can
+ * render the link) and `authorized` in JSON mode; prints a friendly block and
+ * auto-opens the browser in interactive mode.
+ *
+ * Throws LayeroError("auth_expired" | "auth_timeout") if the user doesn't
+ * approve in time.
+ */
+export async function runDeviceLogin(cfg) {
+    const mode = detectMode();
+    const api = new ApiClient(cfg);
+    const device = await api.startDeviceAuth();
+    const { device_code, user_code, verification_url, poll_interval } = device;
+    const pollMs = (poll_interval ?? 2) * 1000;
+    if (mode.json) {
+        emit({ event: "auth_required", url: verification_url, user_code });
+    }
+    else {
+        console.log(chalk.cyan("\nOpen this URL to sign in:"));
+        console.log(chalk.bold(`  ${verification_url}`));
+        console.log(chalk.dim(`\n  Confirmation code: `) + chalk.white.bold(user_code));
+        console.log(chalk.dim(`  (expires in ${device.expires_in}s)\n`));
+        try {
+            await open(verification_url);
+        }
+        catch {
+            // non-fatal — user can paste the URL manually
+        }
+    }
+    const deadline = Date.now() + MAX_WAIT_MS;
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, pollMs));
+        const poll = await api.pollDeviceAuth(device_code);
+        if (poll.status === "approved" && poll.token) {
+            cfg.token = poll.token;
+            const probe = new ApiClient(cfg);
+            const me = await probe.me();
+            cfg.user = { id: me.id, username: me.username, email: me.email };
+            await saveConfig(cfg);
+            if (mode.json) {
+                emit({ event: "authorized", user: me.username ?? me.email ?? me.id });
+            }
+            else {
+                console.log(chalk.green(`Logged in as ${me.username ?? me.email ?? me.id}`));
+                if (!me.username) {
+                    console.log(chalk.yellow("No username set — open https://app.layero.ru/onboarding to pick one."));
+                }
+            }
+            return cfg;
+        }
+        if (poll.status === "expired") {
+            throw new LayeroError("auth_expired", "Login timed out — code expired. Run `layero login` again.", "run_login");
+        }
+    }
+    throw new LayeroError("auth_timeout", "Login timed out. Run `layero login` again.", "run_login");
+}

package/dist/bin/layero.js

@@ -26,7 +26,8 @@ async function main() {
         .name("layero")
         .description("Layero CLI — publish a local directory with one command. No git required.")
         .version(VERSION)
-        .option("--json", "emit machine-readable JSON-lines on stdout (for agents and CI)");
+        .option("--json", "emit machine-readable JSON-lines on stdout (for agents and CI)")
+        .option("--debug", "print a full stack trace when a command errors");
     program
         .command("login")
         .description("Authenticate via browser (GitHub / Yandex). Opens a one-time URL — no localhost server required.")
@@ -44,9 +45,9 @@ async function main() {
         .action(whoamiCmd);
     program
         .command("init")
-        .description("Scaffold .layero/project.json from auto-detected framework, and write a Layero deployment block into AGENTS.md / CLAUDE.md / .cursorrules so future chat sessions know how to deploy.")
+        .description("Scaffold .layero/project.json from the auto-detected framework, and write a Layero deployment block into your agent-instructions file so future chat sessions know how to deploy. Updates whichever of AGENTS.md / CLAUDE.md / .cursorrules already exist; if none do, creates AGENTS.md.")
         .option("-y, --yes", "non-interactive: accept all defaults")
-        .option("--skip-agent-docs", "do not touch AGENTS.md/CLAUDE.md/.cursorrules")
+        .option("--skip-agent-docs", "do not touch AGENTS.md / CLAUDE.md / .cursorrules")
         .action(async (opts) => {
         await initCmd({ yes: opts.yes, skipAgentDocs: opts.skipAgentDocs });
     });
@@ -196,6 +197,12 @@ async function main() {
 }
 main().catch((err) => {
     const mode = detectMode();
+    // `--debug` (real global flag) prints the full stack trace for any error,
+    // structured or not, so the next_action hint that mentions it is honest.
+    const debug = process.argv.includes("--debug") || process.env.LAYERO_DEBUG === "1";
+    if (debug && err instanceof Error && err.stack) {
+        console.error(chalk.dim(err.stack));
+    }
     if (err instanceof LayeroError) {
         emit({
             event: "error",
@@ -212,12 +219,17 @@ main().catch((err) => {
             emit({
                 event: "error",
                 code: "internal",
-                next_action: "re-run with --debug for a stack trace, or report at https://github.com/layero/layero/issues",
+                next_action: debug
+                    ? "report at https://github.com/LayeroInfra/core/issues"
+                    : "re-run with --debug for a stack trace, or report at https://github.com/LayeroInfra/core/issues",
                 message,
             });
         }
         else {
             console.error(chalk.red(message));
+            if (!debug) {
+                console.error(chalk.dim("  (re-run with --debug for a stack trace)"));
+            }
         }
     }
     process.exit(1);

package/dist/commands/deploy.js

@@ -8,6 +8,7 @@ import { loadProjectConfig, persistProjectLinking, projectConfigPath, } from "..
 import { packCwd, packDirectory } from "../pack.js";
 import { streamDeployLogs } from "../logs.js";
 import { detectProject } from "../detect.js";
+import { runDeviceLogin } from "../auth.js";
 import { LayeroError, detectMode, emit } from "../agent.js";
 const VALID_TYPES = new Set([
     "vite",
@@ -44,6 +45,33 @@ function dashboardOrigin(apiUrl) {
 function projectUrl(apiUrl, projectId) {
     return `${dashboardOrigin(apiUrl)}/projects/${projectId}`;
 }
+/**
+ * After a deploy reaches `ready`, ask the backend where it's actually
+ * reachable. The builder marks status=ready *before* calling /activate
+ * (which runs auto-promote + schedules CDN warmup), so a probe fired the
+ * instant we see `ready` can race ahead of the apex pointer being set.
+ *
+ * Poll the probe briefly (bounded) and return as soon as the env is
+ * reachable (`available` — the preview host is up) or we learn the CDN
+ * edge is already warm. Best-effort: any error returns null and the caller
+ * falls back to apex/dashboard URLs.
+ */
+async function resolveReachability(api, environmentId) {
+    const deadline = Date.now() + 15_000;
+    let last = null;
+    while (Date.now() < deadline) {
+        try {
+            last = await api.probeEnvironment(environmentId);
+        }
+        catch {
+            return last; // permission/network — caller falls back
+        }
+        if (last.available || last.cdn_ready)
+            return last;
+        await new Promise((r) => setTimeout(r, 1500));
+    }
+    return last;
+}
 async function prompt(question, fallback) {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -87,7 +115,15 @@ async function resolveOrCreateProject(api, cwd, opts, existing) {
         }
         return { project: match, createdNow: false };
     }
-    if (existing) {
+    // Treat the local config as a real link only if it actually carries a
+    // project_id. `layero init` scaffolds .layero/project.json with the
+    // detected framework/build/output but NO project_id (the project isn't
+    // created until the first deploy). Without this guard, deploy would treat
+    // that scaffold as an existing link and call GET /projects/undefined → 422
+    // (B1 — the documented init→deploy path was broken). When there's no id,
+    // fall through to the create path below, which preserves the scaffold's
+    // setup fields via persistProjectLinking().
+    if (existing && existing.project_id) {
         try {
             const project = await api.getProject(existing.project_id);
             return { project, createdNow: false };
@@ -242,9 +278,13 @@ export async function deployCmd(opts) {
     if (opts.type && !VALID_TYPES.has(opts.type.toLowerCase())) {
         throw new LayeroError("invalid_type", `unknown --type "${opts.type}"`, `valid types: ${[...VALID_TYPES].join(", ")}`);
     }
-    const cliCfg = await loadConfig();
+    let cliCfg = await loadConfig();
     if (!cliCfg.token) {
-        throw new LayeroError("not_logged_in", "not authenticated", "run: layero login");
+        // Not authenticated yet. Kick off the browser device-login flow inline
+        // and poll, exactly as the docs describe (B5/I4) — no separate `layero
+        // login` step required. In JSON/agent mode this emits `auth_required`
+        // so the caller can render the link and keep waiting.
+        cliCfg = await runDeviceLogin(cliCfg);
     }
     const api = new ApiClient(cliCfg);
     const cwd = process.cwd();
@@ -375,14 +415,39 @@ export async function deployCmd(opts) {
                     `  retry with: layero promote ${deploy.id.slice(0, 8)}`));
             }
         }
+        // Where is this build actually reachable? Ask the backend rather than
+        // guessing — it knows the live public URL (apex once it's the production
+        // pointer), the off-CDN preview URL that's reachable immediately, and
+        // how far along CDN propagation is. Note: a plain `layero deploy` of a
+        // CLI project auto-promotes to the apex on activate (no `--prod` /
+        // `promote` needed), so the apex IS the destination for the common case.
+        const dashboardUrl = projectUrl(cliCfg.apiUrl, project.id);
         const apexUrl = `https://${project.apex_hostname}`;
-        const previewUrl = projectUrl(cliCfg.apiUrl, project.id);
-        const liveUrl = promoted || (opts.prod && !opts.branch) ? apexUrl : previewUrl;
+        const probe = await resolveReachability(api, deploy.environment_id);
+        // Public site URL — honour the preview-first contract the dashboard uses
+        // (probe states B/C): until the CDN apex is verified live (`cdn_ready`),
+        // the reachable address is the off-CDN preview domain. A fresh apex
+        // 404/000s for ~10-15min while CDN propagates, and for runtime apps the
+        // preview domain is the *permanent* address (the CDN apex can't serve
+        // POST/WebSocket). So only surface the canonical apex once it's warm;
+        // before that, hand back the preview. `edge_ready` / `edge_eta_seconds`
+        // below tell the caller the apex is on its way.
+        const cdnWarm = probe?.cdn_ready === true;
+        const liveUrl = cdnWarm
+            ? probe?.canonical_url ?? apexUrl
+            : probe?.preview_url ??
+                probe?.canonical_url ??
+                (promoted || !opts.branch ? apexUrl : dashboardUrl);
         emit({
             event: "ready",
             url: liveUrl,
             deploy_id: deploy.id,
-            preview_url: promoted || (opts.prod && !opts.branch) ? undefined : previewUrl,
+            preview_url: probe?.preview_url ?? undefined,
+            dashboard_url: dashboardUrl,
+            edge_ready: probe ? probe.cdn_ready : undefined,
+            edge_eta_seconds: probe && !probe.cdn_ready && probe.cdn_eta_seconds != null
+                ? probe.cdn_eta_seconds
+                : undefined,
         });
     }
     finally {

package/dist/commands/deploys.js

@@ -3,6 +3,7 @@ import chalk from "chalk";
 import { ApiClient, ApiError } from "../api.js";
 import { loadConfig } from "../config.js";
 import { loadProjectConfig } from "../project-config.js";
+import { detectMode } from "../agent.js";
 async function resolveProjectId(api, cwd, override) {
     if (override) {
         // Accept slug or id; resolve via list to keep consistent error UX.
@@ -59,6 +60,25 @@ export async function deploysListCmd(opts) {
     const deploys = await api.listProjectDeploys(projectId, opts.branch);
     const limit = opts.limit ?? 20;
     const rows = deploys.slice(0, limit);
+    // JSON mode (B6): emit one structured object per deploy on stdout instead
+    // of the coloured human one-liner. One JSON object per line keeps it
+    // consistent with the rest of the CLI's JSON-lines protocol.
+    if (detectMode().json) {
+        for (const d of rows) {
+            process.stdout.write(JSON.stringify({
+                event: "deploy",
+                id: d.id,
+                environment_id: d.environment_id,
+                status: d.status,
+                commit_sha: d.commit_sha,
+                commit_message: (d.commit_message ?? "").split("\n")[0] ?? "",
+                source_type: d.source_type ?? "github",
+                created_at: d.created_at ?? null,
+                finished_at: d.finished_at ?? null,
+            }) + "\n");
+        }
+        return;
+    }
     if (rows.length === 0) {
         console.log(chalk.dim("no deploys yet."));
         return;

package/dist/commands/init.js

@@ -20,7 +20,8 @@ is required — Layero packs and uploads the local directory directly.
 
 ### First-time auth (one-click device flow)
 
-The first run emits a JSON line:
+If you're not logged in yet, \`deploy\` (or \`login\`) starts the browser
+device-flow automatically and emits a JSON line:
 
 \`\`\`json
 {"event":"auth_required","url":"https://app.layero.ru/cli?code=ABCD-1234","user_code":"ABCD-1234"}
@@ -43,7 +44,7 @@ stdout), the CLI auto-switches to JSON-lines. Key events to watch:
 | \`detected\` | framework auto-detection result |
 | \`project_created\` / \`project_linked\` | project bound for this directory |
 | \`build_log\` | forward only if it contains errors |
-| \`ready\` | \`url\` field is the live site — show to user, stop |
+| \`ready\` | \`url\` = live public site (show to user, stop). \`preview_url\` = reachable immediately while the apex CDN edge warms; \`edge_ready\`/\`edge_eta_seconds\` say whether the apex is serving yet. \`dashboard_url\` = management page. |
 | \`error\` | follow \`next_action\` field verbatim |
 
 Common error codes and remediation:
@@ -56,11 +57,32 @@ Common error codes and remediation:
 
 ### Re-deploys and production
 
-Each \`npx layero deploy\` produces a new preview URL like
-\`https://<org>-<project>-cli.layero.ru\` — safe to run repeatedly.
+A plain \`npx layero deploy\` of a CLI project **publishes to the apex**
+\`https://<org>-<project>.layero.ru\` — direct uploads auto-promote, so you do
+**not** need \`--prod\` or a separate \`promote\` step. Safe to run repeatedly;
+each run replaces what the apex serves.
 
-Add \`--prod\` only when the user explicitly asks; without it, deploys go to
-an isolated preview branch and never replace the apex domain.
+Every deploy also gets a per-deploy preview at
+\`https://<org>-<project>-<sha>.preview.layero.ru\` (read it from \`ready.preview_url\`).
+The preview is reachable **immediately**; the apex can take a few minutes to
+serve on the **first** deploy of a project while the CDN edge issues its cert
+and propagates (\`ready.edge_ready=false\` with an \`edge_eta_seconds\` estimate).
+Hand the user \`ready.url\` (the apex); if \`edge_ready\` is false, also offer
+\`preview_url\` so they can see it right away.
+
+Use \`--branch <name>\` to deploy to an isolated preview environment that does
+**not** touch the apex. (\`--prod\` exists for git-connected projects; for
+direct CLI uploads it's redundant.)
+
+### Already built? Skip the server build
+
+If the site is already built locally (e.g. a Next.js static export in \`out/\`,
+or a \`dist/\`), ship the artifact directly and skip the server-side
+\`npm install\` + build:
+
+\`\`\`bash
+npx layero@latest deploy --prebuilt out
+\`\`\`
 
 Full reference: https://docs.layero.ru/cli/agents
 ${AGENT_BLOCK_MARKER_END}

package/dist/commands/login.js

@@ -1,55 +1,6 @@
-import chalk from "chalk";
-import open from "open";
-import { loadConfig, saveConfig } from "../config.js";
-import { ApiClient } from "../api.js";
-import { LayeroError, detectMode, emit } from "../agent.js";
-const MAX_WAIT_MS = 15 * 60 * 1000;
+import { loadConfig } from "../config.js";
+import { runDeviceLogin } from "../auth.js";
 export async function loginCmd(_opts) {
     const cfg = await loadConfig();
-    const mode = detectMode();
-    const api = new ApiClient(cfg);
-    const device = await api.startDeviceAuth();
-    const { device_code, user_code, verification_url, poll_interval } = device;
-    const pollMs = (poll_interval ?? 2) * 1000;
-    if (mode.json) {
-        emit({ event: "auth_required", url: verification_url, user_code });
-    }
-    else {
-        console.log(chalk.cyan("\nOpen this URL to sign in:"));
-        console.log(chalk.bold(`  ${verification_url}`));
-        console.log(chalk.dim(`\n  Confirmation code: `) + chalk.white.bold(user_code));
-        console.log(chalk.dim(`  (expires in ${device.expires_in}s)\n`));
-        try {
-            await open(verification_url);
-        }
-        catch {
-            // non-fatal — user can paste the URL manually
-        }
-    }
-    const deadline = Date.now() + MAX_WAIT_MS;
-    while (Date.now() < deadline) {
-        await new Promise((r) => setTimeout(r, pollMs));
-        const poll = await api.pollDeviceAuth(device_code);
-        if (poll.status === "approved" && poll.token) {
-            cfg.token = poll.token;
-            const probe = new ApiClient(cfg);
-            const me = await probe.me();
-            cfg.user = { id: me.id, username: me.username, email: me.email };
-            await saveConfig(cfg);
-            if (mode.json) {
-                emit({ event: "authorized", user: me.username ?? me.email ?? me.id });
-            }
-            else {
-                console.log(chalk.green(`Logged in as ${me.username ?? me.email ?? me.id}`));
-                if (!me.username) {
-                    console.log(chalk.yellow("No username set — open https://app.layero.ru/onboarding to pick one."));
-                }
-            }
-            return;
-        }
-        if (poll.status === "expired") {
-            throw new LayeroError("auth_expired", "Login timed out — code expired. Run `layero login` again.", "run_login");
-        }
-    }
-    throw new LayeroError("auth_timeout", "Login timed out. Run `layero login` again.", "run_login");
+    await runDeviceLogin(cfg);
 }

package/dist/commands/promote.js

@@ -3,6 +3,7 @@ import chalk from "chalk";
 import { ApiClient, ApiError } from "../api.js";
 import { loadConfig } from "../config.js";
 import { loadProjectConfig } from "../project-config.js";
+import { detectMode, emit } from "../agent.js";
 async function resolveProjectId(api, cwd, override) {
     if (override) {
         const all = await api.listProjects();
@@ -45,6 +46,7 @@ async function confirm(question) {
  * returns 400 with a readable message if the flag is off; we surface it.
  */
 export async function promoteCmd(deployArg, opts) {
+    const mode = detectMode();
     const cliCfg = await loadConfig();
     if (!cliCfg.token) {
         throw new Error("not logged in. run `layero login` first.");
@@ -77,14 +79,21 @@ export async function promoteCmd(deployArg, opts) {
         throw new Error(`cannot promote deploy ${shortSha(target.commit_sha)}: status is "${target.status}", not ready.`);
     }
     const apex = project.apex_hostname;
-    console.log(chalk.cyan("promote plan:"));
-    console.log(`  project: ${project.slug}`);
-    console.log(`  apex:    https://${apex}`);
-    console.log(`  deploy:  ${shortSha(target.commit_sha)}  ${chalk.dim((target.commit_message ?? "").split("\n")[0] ?? "")}`);
-    if (project.production_deploy_id) {
-        console.log(chalk.dim(`  current: ${project.production_deploy_id.slice(0, 8)}  (will be replaceable via re-promote)`));
+    // Human-only plan. In JSON mode we skip the chatter and emit a single
+    // structured `promoted` event below.
+    if (!mode.json) {
+        console.log(chalk.cyan("promote plan:"));
+        console.log(`  project: ${project.slug}`);
+        console.log(`  apex:    https://${apex}`);
+        console.log(`  deploy:  ${shortSha(target.commit_sha)}  ${chalk.dim((target.commit_message ?? "").split("\n")[0] ?? "")}`);
+        if (project.production_deploy_id) {
+            console.log(chalk.dim(`  current: ${project.production_deploy_id.slice(0, 8)}  (will be replaceable via re-promote)`));
+        }
     }
-    if (!opts.yes) {
+    // Confirm only when there's a human at a TTY. In --json / agent / CI /
+    // non-interactive mode, never block on a prompt (B6) — proceed, matching
+    // `deploy --prod`'s non-interactive behaviour. `--yes` forces it anywhere.
+    if (!opts.yes && mode.interactive) {
         const ok = await confirm("publish this build to production?");
         if (!ok) {
             console.log(chalk.yellow("aborted."));
@@ -94,8 +103,17 @@ export async function promoteCmd(deployArg, opts) {
     try {
         const updated = await api.promoteDeploy(projectId, target.id);
         const newPin = updated.production_deploy_id ?? target.id;
-        console.log(chalk.green(`published. https://${updated.apex_hostname} now serves deploy ${newPin.slice(0, 8)}.`));
-        console.log(chalk.dim("  edge cache flushes within a few seconds; visitors see the new build immediately."));
+        if (mode.json) {
+            emit({
+                event: "promoted",
+                url: `https://${updated.apex_hostname}`,
+                deploy_id: target.id,
+            });
+        }
+        else {
+            console.log(chalk.green(`published. https://${updated.apex_hostname} now serves deploy ${newPin.slice(0, 8)}.`));
+            console.log(chalk.dim("  edge cache flushes within a few seconds; visitors see the new build immediately."));
+        }
     }
     catch (err) {
         if (err instanceof ApiError) {

package/dist/detect.js

@@ -1,499 +1,178 @@
 import { promises as fs } from "node:fs";
 import path from "node:path";
-async function readPkg(cwd) {
+import * as dc from "layero-detection";
+async function readJson(p) {
     try {
-        const raw = await fs.readFile(path.join(cwd, "package.json"), "utf-8");
-        return JSON.parse(raw);
+        return JSON.parse(await fs.readFile(p, "utf-8"));
     }
-    catch (err) {
-        if (err?.code === "ENOENT")
-            return null;
-        throw err;
+    catch {
+        return null;
     }
 }
-function hasDep(pkg, name) {
-    return Boolean(pkg.dependencies?.[name] ?? pkg.devDependencies?.[name]);
+async function readText(p) {
+    try {
+        return await fs.readFile(p, "utf-8");
+    }
+    catch {
+        return null;
+    }
 }
-async function fileExists(cwd, ...candidates) {
-    for (const c of candidates) {
-        try {
-            await fs.access(path.join(cwd, c));
+const HTML_SKIP_DIRS = new Set(["node_modules", ".git", ".cache", "dist", "build", "out", "public"]);
+async function dirHasHtml(base, depth = 0) {
+    if (depth > 6)
+        return false;
+    let entries;
+    try {
+        entries = await fs.readdir(base, { withFileTypes: true });
+    }
+    catch {
+        return false;
+    }
+    for (const e of entries) {
+        if (e.isFile() && (e.name.endsWith(".html") || e.name.endsWith(".htm")))
             return true;
-        }
-        catch {
-            // try next
+    }
+    for (const e of entries) {
+        if (e.isDirectory() && !HTML_SKIP_DIRS.has(e.name)) {
+            if (await dirHasHtml(path.join(base, e.name), depth + 1))
+                return true;
         }
     }
     return false;
 }
-// Python runtime: `app.py` entry + a runtime lib in requirements.txt.
-// Lockstep with detect_runtime() (backend) / runtime_detect.py (builder):
-// app.py + requirements.txt mentioning streamlit | gradio | flask.
-async function detectPythonRuntime(cwd) {
-    if (!(await fileExists(cwd, "app.py")))
-        return null;
-    let reqs;
+/** Build a detect_core Snapshot from the local filesystem (the CLI's disk
+ * fidelity — the analogue of detect_core.py's snapshot_from_dir). */
+async function snapshotFromDir(cwd) {
+    const files = new Set();
+    const dirs = new Set();
     try {
-        reqs = (await fs.readFile(path.join(cwd, "requirements.txt"), "utf-8")).toLowerCase();
+        for (const e of await fs.readdir(cwd, { withFileTypes: true })) {
+            (e.isDirectory() ? dirs : files).add(e.name);
+        }
     }
     catch {
-        return null;
-    }
-    for (const lib of ["streamlit", "gradio", "flask"]) {
-        if (reqs.includes(lib))
-            return lib;
+        /* empty / unreadable cwd */
     }
-    return null;
-}
-// Mirrors `frameworks/nextjs.py:_NEXT_STATIC_EXPORT_RE` and
-// `next_config_static_export()` so CLI and builder can't disagree on
-// what counts as a static-export Next.js project. The class-of-bug we
-// hit on 2026-05-22 (builder detector v72 fix) and 2026-05-26 (CLI side)
-// was exactly this kind of dual detector drift.
-const NEXT_STATIC_EXPORT_RE = /output\s*:\s*['"]export['"]/m;
-// Strip JS line and block comments before regex matching. Without this,
-// a comment like `// see output: 'export'` falsely matches as
-// static-export — observed 2026-05-26 on the SSR smoke canary fixture.
-// Naive (does not understand strings that contain comment-like tokens),
-// but real next.config files don't have that shape.
-const JS_COMMENT_RE = /\/\/[^\n]*|\/\*[\s\S]*?\*\//gm;
-const stripJsComments = (text) => text.replace(JS_COMMENT_RE, "");
-async function readNextConfigText(cwd) {
-    for (const name of ["next.config.mjs", "next.config.ts", "next.config.js", "next.config.cjs"]) {
+    for (const nested of [
+        ".vitepress/config.ts", ".vitepress/config.js", ".vitepress/config.mts", ".vitepress/config.mjs",
+        "docs/.vitepress/config.ts", "docs/.vitepress/config.js", "docs/.vitepress/config.mts", "docs/.vitepress/config.mjs",
+    ]) {
         try {
-            return await fs.readFile(path.join(cwd, name), "utf-8");
+            await fs.access(path.join(cwd, nested));
+            files.add(nested);
         }
-        catch (err) {
-            if (err?.code === "ENOENT")
-                continue;
-            return null;
-        }
-    }
-    return null;
+        catch {
+            /* absent */
+        }
+    }
+    const packageJson = (await readJson(path.join(cwd, "package.json")));
+    const requirementsTxt = await readText(path.join(cwd, "requirements.txt"));
+    const layeroJson = await readJson(path.join(cwd, "layero.json"));
+    const configTexts = {};
+    const candidates = new Set(dc.CONFIG_TEXT_FILES);
+    for (const bn of dc.CONFIG_TEXT_BASENAMES)
+        for (const ext of dc.CONFIG_EXTENSIONS)
+            candidates.add(bn + ext);
+    // nuxt.config / svelte.config drive the SSR warning below.
+    for (const n of ["nuxt.config.mjs", "nuxt.config.ts", "nuxt.config.js", "svelte.config.js", "svelte.config.ts"])
+        candidates.add(n);
+    for (const name of candidates) {
+        const t = await readText(path.join(cwd, name));
+        if (t !== null)
+            configTexts[name] = t.slice(0, 64 * 1024);
+    }
+    return dc.snapshotFromInputs({
+        packageJson,
+        requirementsTxt,
+        files,
+        dirs,
+        configTexts,
+        layeroJson: layeroJson && typeof layeroJson === "object" ? layeroJson : null,
+        hasHtml: await dirHasHtml(cwd),
+    });
 }
-// True  -> config has `output: 'export'` (static-export SPA).
-// False -> config exists but no export marker (SSR Next.js).
-// null  -> no next.config file at all; caller treats as static-default.
-async function nextConfigStaticExport(cwd) {
-    const text = await readNextConfigText(cwd);
-    if (text === null)
-        return null;
-    return NEXT_STATIC_EXPORT_RE.test(stripJsComments(text));
+const NUXT_STATIC_SSR_RE = /\bssr\s*:\s*false\b/m;
+const NUXT_STATIC_PRESET_RE = /preset\s*:\s*['"]static['"]/m;
+const JS_COMMENT_RE = /\/\/[^\n]*|\/\*[\s\S]*?\*\//gm;
+function hasDep(pkg, name) {
+    return Boolean(pkg && ((pkg.dependencies ?? {})[name] ?? (pkg.devDependencies ?? {})[name]));
 }
-async function hasAnyHtml(cwd) {
-    // Shallow check — only top-level. Recursive walk is too expensive here
-    // and the static fallback is already permissive enough.
-    try {
-        const entries = await fs.readdir(cwd);
-        return entries.some((e) => e.endsWith(".html") || e.endsWith(".htm"));
+/** Mirror of the builder's static-host pre-flight warning for the two
+ * frameworks that build a server by default (Nuxt, SvelteKit). */
+function ssrWarning(snap, framework) {
+    const pkg = snap.packageJson;
+    if (framework === "nuxt") {
+        const scripts = pkg?.scripts ?? {};
+        const hasGenerate = Object.values(scripts).some((v) => typeof v === "string" && v.includes("nuxt generate"));
+        let declaresStatic = false;
+        for (const n of ["nuxt.config.mjs", "nuxt.config.ts", "nuxt.config.js"]) {
+            const txt = snap.configTexts[n];
+            if (txt !== undefined) {
+                const stripped = txt.replace(JS_COMMENT_RE, "");
+                declaresStatic = NUXT_STATIC_SSR_RE.test(stripped) || NUXT_STATIC_PRESET_RE.test(stripped);
+                break;
+            }
+        }
+        if (!hasGenerate && !declaresStatic) {
+            return ("Nuxt без `nuxt generate` или `ssr: false` собирается как SSR-сервер; " +
+                "Layero хостит только статику Nuxt. Добавьте `\"generate\": \"nuxt generate\"` " +
+                "в scripts или поставьте `ssr: false` в nuxt.config.");
+        }
     }
-    catch {
-        return false;
+    if (framework === "sveltekit") {
+        const hasStatic = hasDep(pkg, "@sveltejs/adapter-static");
+        if (hasStatic)
+            return undefined;
+        const allDeps = { ...(pkg?.dependencies ?? {}), ...(pkg?.devDependencies ?? {}) };
+        const serverAdapter = Object.keys(allDeps).find((d) => d.startsWith("@sveltejs/adapter-") && d !== "@sveltejs/adapter-static");
+        if (serverAdapter) {
+            return `SvelteKit использует ${serverAdapter} (серверный адаптер). Layero хостит только статику — поставьте @sveltejs/adapter-static.`;
+        }
+        return "SvelteKit без явного адаптера — поставьте @sveltejs/adapter-static для статического хостинга.";
     }
-}
-// Build command preference:
-//   1. If `scripts.build` exists in package.json, use `npm run build` —
-//      it respects whatever the user set up (custom flags, monorepo
-//      filters, etc.). `npm run` works regardless of package manager
-//      installed on the build VM, because the builder runs `npm` itself.
-//   2. Otherwise, use the framework's CLI directly via `npx`.
-function buildCmd(pkg, fallback) {
-    if (pkg?.scripts?.build)
-        return "npm run build";
-    return fallback;
+    return undefined;
 }
 /**
- * Detect framework / build command / output directory from the project
- * shape. Mirrors the builder's detector ([core/builder/src/frameworks])
- * so the values we ship to `completeSetup` match what the builder will
- * actually do at build time.
- *
- * Order matters: more specific signals first (Next, Nuxt, SvelteKit,
- * Gatsby, Astro, Docusaurus) before catch-alls (Vite, CRA, static).
+ * Detect framework / build command / output directory from the project shape.
+ * Identity now comes from the unified detect_core (the same spec the builder
+ * and backend wizard use); this function only adapts the resulting BuildPlan
+ * into the CLI's `Detected` shape and its conventions (SSR Next reports `.next`,
+ * runtime apps report a `static` placeholder + runtime_kind).
  */
 export async function detectProject(cwd) {
-    const pkg = await readPkg(cwd);
-    if (pkg) {
-        if (hasDep(pkg, "next") || (await fileExists(cwd, "next.config.js", "next.config.mjs", "next.config.ts", "next.config.cjs"))) {
-            // A Next.js repo is SSR unless next.config explicitly declares
-            // `output: 'export'`. We only flag ssr_next when the config file
-            // exists AND lacks the export marker — same rule the builder uses
-            // in `runtime_detect.py:46`. Without a next.config file at all we
-            // err on the side of static (legacy `next export` workflow).
-            const exportFlag = await nextConfigStaticExport(cwd);
-            const isSsr = exportFlag === false;
+    const snap = await snapshotFromDir(cwd);
+    const plan = dc.detect(snap);
+    if (plan.runtimeKind !== null) {
+        if (plan.projectType === "ssr_next") {
+            // SSR Next builds in the runtime-builder; surface the framework + the
+            // `.next` dir the CLI has always reported (vestigial but expected).
+            const [unit] = dc.detectFramework(snap, "nextjs");
             return {
                 framework_hint: "nextjs",
-                build_cmd: buildCmd(pkg, "npx next build"),
-                output_dir: isSsr ? ".next" : "out",
+                build_cmd: unit.buildCmd ?? "npx next build",
+                output_dir: ".next",
                 confident: true,
-                ...(isSsr ? { runtime_kind: "ssr_next" } : {}),
+                runtime_kind: "ssr_next",
             };
         }
-        if (hasDep(pkg, "nuxt") || hasDep(pkg, "nuxt3") || (await fileExists(cwd, "nuxt.config.ts", "nuxt.config.js", "nuxt.config.mjs"))) {
-            const generateScript = pkg.scripts?.generate;
-            const buildScript = pkg.scripts?.build;
-            const cmd = generateScript
-                ? "npm run generate"
-                : buildScript
-                    ? "npm run build"
-                    : "npx nuxt generate";
-            // Nuxt defaults to SSR. Layero hosts only static for Nuxt today,
-            // so a project without an explicit static signal (`nuxt generate`
-            // script, or `ssr: false` / `nitro.preset='static'` in config)
-            // will build but the resulting `.output/server/` is useless to us.
-            // Mirrors builder's `frameworks/nuxt.py` SSR hint.
-            const nuxtStatic = !!generateScript || (await nuxtConfigDeclaresStatic(cwd));
-            return {
-                framework_hint: "nuxt",
-                build_cmd: cmd,
-                output_dir: ".output/public",
-                confident: true,
-                ...(nuxtStatic ? {} : {
-                    ssr_warning: "Nuxt без `nuxt generate` или `ssr: false` собирается как SSR-сервер; " +
-                        "Layero хостит только статику Nuxt. Добавьте `\"generate\": \"nuxt generate\"` " +
-                        "в scripts или поставьте `ssr: false` в nuxt.config.",
-                }),
-            };
-        }
-        // Remix / React Router v7 before SvelteKit/Vite — RR7 ships Vite
-        // internally, so the Vite-dep check would otherwise win. Mirrors the
-        // builder's RemixFramework + backend `remix` table entry (output
-        // build/client). Was missing from the CLI entirely — same dual-detector
-        // gap class as Angular: a Remix repo deployed via the CLI fell through
-        // to the static fallback and shipped raw sources.
-        if (hasDep(pkg, "@remix-run/dev") ||
-            hasDep(pkg, "@remix-run/react") ||
-            hasDep(pkg, "@remix-run/node") ||
-            hasDep(pkg, "@react-router/dev") ||
-            hasDep(pkg, "@react-router/node") ||
-            (await fileExists(cwd, "react-router.config.ts", "react-router.config.js"))) {
-            return {
-                framework_hint: "remix",
-                build_cmd: buildCmd(pkg, "npx react-router build"),
-                output_dir: "build/client",
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "@sveltejs/kit") || (await fileExists(cwd, "svelte.config.js"))) {
-            // SvelteKit needs an adapter. adapter-static = SPA path; anything
-            // else (adapter-node, adapter-auto, …) is server-side. Mirrors
-            // builder's `frameworks/svelte.py:validate_static`.
-            const hasStaticAdapter = hasDep(pkg, "@sveltejs/adapter-static");
-            const serverAdapter = !hasStaticAdapter
-                ? Object.keys({ ...(pkg.dependencies ?? {}), ...(pkg.devDependencies ?? {}) })
-                    .find((d) => d.startsWith("@sveltejs/adapter-") && d !== "@sveltejs/adapter-static")
-                : undefined;
-            let ssrWarning;
-            if (serverAdapter) {
-                ssrWarning =
-                    `SvelteKit использует ${serverAdapter} (серверный адаптер). ` +
-                        "Layero хостит только статику — поставьте `@sveltejs/adapter-static`.";
-            }
-            else if (!hasStaticAdapter) {
-                ssrWarning =
-                    "SvelteKit без явного адаптера — поставьте `@sveltejs/adapter-static` " +
-                        "для статического хостинга на Layero.";
-            }
-            return {
-                framework_hint: "sveltekit",
-                build_cmd: buildCmd(pkg, "npx vite build"),
-                output_dir: "build",
-                confident: true,
-                ...(ssrWarning ? { ssr_warning: ssrWarning } : {}),
-            };
-        }
-        if (hasDep(pkg, "gatsby") || (await fileExists(cwd, "gatsby-config.js", "gatsby-config.ts"))) {
-            return {
-                framework_hint: "gatsby",
-                build_cmd: buildCmd(pkg, "npx gatsby build"),
-                output_dir: "public",
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "astro") || (await fileExists(cwd, "astro.config.mjs", "astro.config.ts", "astro.config.js"))) {
-            return {
-                framework_hint: "astro",
-                build_cmd: buildCmd(pkg, "npx astro build"),
-                output_dir: "dist",
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "@docusaurus/core") || (await fileExists(cwd, "docusaurus.config.js", "docusaurus.config.ts", "docusaurus.config.mjs"))) {
-            return {
-                framework_hint: "docusaurus",
-                build_cmd: buildCmd(pkg, "npx docusaurus build"),
-                output_dir: "build",
-                confident: true,
-            };
-        }
-        // Storybook before Vite/CRA: Storybook 7+ uses Vite or webpack
-        // internally, so `vite` / `react-scripts` is in deps. Without
-        // listing it first the SPA Vite path would output_dir=dist, which
-        // doesn't exist after `build-storybook`.
-        const storybookDeps = [
-            "@storybook/cli",
-            "@storybook/react",
-            "@storybook/react-vite",
-            "@storybook/react-webpack5",
-            "@storybook/vue",
-            "@storybook/vue3",
-            "@storybook/vue3-vite",
-            "@storybook/svelte",
-            "@storybook/svelte-vite",
-            "@storybook/web-components",
-            "@storybook/web-components-vite",
-            "@storybook/preact",
-            "@storybook/angular",
-            "@storybook/nextjs",
-            "@storybook/html",
-            "@storybook/html-vite",
-            "storybook",
-        ];
-        const hasStorybookDep = storybookDeps.some((d) => hasDep(pkg, d));
-        const hasStorybookScript = pkg.scripts?.["build-storybook"] !== undefined
-            || Object.values(pkg.scripts ?? {}).some((s) => typeof s === "string" && s.includes("storybook build"));
-        const hasStorybookDir = await fileExists(cwd, ".storybook/main.js", ".storybook/main.ts", ".storybook/main.cjs", ".storybook/main.mjs");
-        if (hasStorybookDep || hasStorybookScript || hasStorybookDir) {
-            const cmd = pkg.scripts?.["build-storybook"]
-                ? "npm run build-storybook"
-                : (pkg.scripts?.build && pkg.scripts.build.includes("storybook"))
-                    ? "npm run build"
-                    : "npx storybook build";
-            return {
-                framework_hint: "storybook",
-                build_cmd: cmd,
-                output_dir: "storybook-static",
-                confident: true,
-            };
-        }
-        // VitePress before generic Vite: VitePress repos often pull `vite`
-        // transitively, and the SPA Vite path would set output_dir=dist —
-        // wrong for VitePress, which writes to `.vitepress/dist/` (or
-        // `docs/.vitepress/dist/` when the config lives under docs/).
-        if (hasDep(pkg, "vitepress") || (await hasVitepressConfig(cwd))) {
-            const docsLayout = await hasVitepressConfig(cwd, "docs/.vitepress");
-            const outputDir = docsLayout ? "docs/.vitepress/dist" : ".vitepress/dist";
-            const cmd = pkg.scripts?.["docs:build"]
-                ? "npm run docs:build"
-                : buildCmd(pkg, "npx vitepress build");
-            return {
-                framework_hint: "vitepress",
-                build_cmd: cmd,
-                output_dir: outputDir,
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "vite") || (await fileExists(cwd, "vite.config.ts", "vite.config.js", "vite.config.mjs"))) {
-            return {
-                framework_hint: "vite",
-                build_cmd: buildCmd(pkg, "npx vite build"),
-                output_dir: "dist",
-                confident: true,
-            };
-        }
-        // Angular after Vite — mirrors builder ALL order. Angular ships its
-        // own CLI (`ng build`) and writes to `dist/{project}/` (Angular <17)
-        // or `dist/{project}/browser/` (17+ `application` builder), NOT bare
-        // `dist`. Until this branch existed the CLI fell through to the
-        // static fallback (`output_dir='.'`), so the first deploy of an
-        // Angular repo shipped the raw sources — the dist/<project> S3 404
-        // incident. `angularOutputDir` parses angular.json to pin the path
-        // (lockstep with `frameworks/angular.py:extract_output_dir`).
-        if (hasDep(pkg, "@angular/core") || (await fileExists(cwd, "angular.json"))) {
-            return {
-                framework_hint: "angular",
-                build_cmd: buildCmd(pkg, "npx ng build"),
-                output_dir: await angularOutputDir(cwd),
-                confident: true,
-            };
-        }
-        if (hasDep(pkg, "react-scripts")) {
-            return {
-                framework_hint: "cra",
-                build_cmd: buildCmd(pkg, "npx react-scripts build"),
-                output_dir: "build",
-                confident: true,
-            };
-        }
-        // Eleventy late in the package.json branch — `@11ty/eleventy` is
-        // unique enough not to collide with other frameworks, but Vite /
-        // CRA / etc. should win if both are present (a project that pulls
-        // both is probably using Vite as the runtime and 11ty just for one
-        // build step).
-        if (hasDep(pkg, "@11ty/eleventy") ||
-            hasDep(pkg, "eleventy") ||
-            (await fileExists(cwd, ".eleventy.js", "eleventy.config.js", "eleventy.config.mjs", "eleventy.config.cjs"))) {
-            return {
-                framework_hint: "eleventy",
-                build_cmd: buildCmd(pkg, "npx @11ty/eleventy"),
-                output_dir: "_site",
-                confident: true,
-            };
-        }
-        // package.json present but no framework matched → a custom Node build,
-        // NOT a static site. Mirrors the backend's detect(): `pkg is None →
-        // _STATIC`, otherwise `_GENERIC` (npm run build → dist). Falling through
-        // to the static fallback here shipped the unbuilt sources — exactly the
-        // `diplomtest` case (Express app + custom build script detected as static
-        // by the CLI but `generic` by the backend).
-        return {
-            framework_hint: "generic",
-            build_cmd: buildCmd(pkg, "npm run build"),
-            output_dir: "dist",
-            confident: false,
-        };
-    }
-    // Python runtimes (Streamlit / Gradio / Flask): an `app.py` entry plus a
-    // runtime lib in requirements.txt. Mirrors detect_runtime() / runtime_detect.py.
-    // No package.json, so without this they fall to the static fallback and ship
-    // `app.py` as a static file (never runs) — the `streamlit-hello` case.
-    const pyRuntime = await detectPythonRuntime(cwd);
-    if (pyRuntime) {
+        // node_web / python_web / streamlit / gradio → static placeholder; the
+        // container serves the app, the SPA pipeline is a no-op.
         return {
             framework_hint: "static",
             build_cmd: "true",
             output_dir: ".",
             confident: true,
-            runtime_kind: pyRuntime,
-        };
-    }
-    // Non-Node SSGs (Hugo today). Recognise repos without package.json
-    // before we fall back to "static" with a no-op build command — Hugo
-    // needs `hugo --gc --minify` and writes to `public/`, the static
-    // fallback would just upload the raw .md sources.
-    if ((await fileExists(cwd, "hugo.toml", "hugo.yaml", "hugo.json")) ||
-        ((await fileExists(cwd, "config.toml", "config.yaml", "config.json")) &&
-            (await hasHugoConfigMarker(cwd)))) {
-        return {
-            framework_hint: "hugo",
-            build_cmd: "hugo --gc --minify",
-            output_dir: "public",
-            confident: true,
+            runtime_kind: plan.projectType,
         };
     }
-    // No (or unrecognised) package.json. If there's HTML on disk we treat
-    // the current directory as a static site. Otherwise we still fall back
-    // to static — it's the most permissive option and the builder will
-    // ship whatever is on disk verbatim.
-    const _staticHtml = await hasAnyHtml(cwd);
+    const framework = plan.framework;
+    const build_cmd = plan.buildCmd ?? (framework === "static" ? "true" : "npm run build");
+    const warning = ssrWarning(snap, framework);
     return {
-        framework_hint: "static",
-        build_cmd: "true",
-        output_dir: ".",
-        confident: _staticHtml,
+        framework_hint: framework,
+        build_cmd,
+        output_dir: plan.outputDir ?? ".",
+        confident: plan.confident,
+        ...(warning ? { ssr_warning: warning } : {}),
     };
 }
-const HUGO_CONFIG_TOKENS = [
-    "baseURL",
-    "baseurl",
-    "languageCode",
-    "languagecode",
-    "[params]",
-    "[markup]",
-    "[menu",
-    "[taxonomies]",
-    "hugoVersion",
-    "minVersion",
-    "theme",
-];
-// Match `ssr: false` or `nitro: { preset: 'static' }` in nuxt.config —
-// either marker keeps the project on the SPA pipeline. Mirrors the same
-// "string-search before AST" approach used for Next.js.
-const NUXT_STATIC_SSR_RE = /\bssr\s*:\s*false\b/m;
-const NUXT_STATIC_PRESET_RE = /preset\s*:\s*['"]static['"]/m;
-async function nuxtConfigDeclaresStatic(cwd) {
-    for (const name of ["nuxt.config.mjs", "nuxt.config.ts", "nuxt.config.js"]) {
-        try {
-            const txt = stripJsComments(await fs.readFile(path.join(cwd, name), "utf-8"));
-            if (NUXT_STATIC_SSR_RE.test(txt) || NUXT_STATIC_PRESET_RE.test(txt))
-                return true;
-            return false; // config found, no static marker → SSR
-        }
-        catch (err) {
-            if (err?.code === "ENOENT")
-                continue;
-            return false;
-        }
-    }
-    return false; // no config at all → defaults to SSR
-}
-async function hasVitepressConfig(cwd, prefix = ".vitepress") {
-    for (const name of ["config.ts", "config.js", "config.mts", "config.mjs"]) {
-        try {
-            await fs.access(path.join(cwd, prefix, name));
-            return true;
-        }
-        catch {
-            // try next
-        }
-    }
-    return false;
-}
-async function hasHugoConfigMarker(cwd) {
-    for (const fn of ["config.toml", "config.yaml", "config.json"]) {
-        try {
-            const head = await fs.readFile(path.join(cwd, fn), "utf-8");
-            if (HUGO_CONFIG_TOKENS.some((t) => head.includes(t)))
-                return true;
-        }
-        catch {
-            // try next
-        }
-    }
-    return false;
-}
-// Resolve Angular's real build output directory from angular.json.
-// Lockstep with `core/builder/src/frameworks/angular.py:extract_output_dir`
-// — same dual-detector-drift class as Next.js static-export, so the two
-// implementations must agree (parity fixtures in
-// core/tests/fixtures/framework-detect/angular-*).
-//
-// Resolution:
-//   1. defaultProject if set & present, else first project in `projects`
-//   2. project.architect.build.options.outputPath, else the CLI default
-//      `dist/{projectName}`
-//   3. strip leading `./`
-//   4. append `/browser` for the Angular 17+ `application` builder
-//      (builder id ends with `:application`) — it writes the served
-//      assets one level deeper. We also probe disk in case the repo was
-//      built locally before `layero deploy`.
-// Returns the framework default `dist` on any parse error — matches
-// AngularFramework.default_output_dir, and the builder re-derives the
-// exact path at upload time anyway.
-async function angularOutputDir(cwd) {
-    const FALLBACK = "dist";
-    let cfg;
-    try {
-        cfg = JSON.parse(await fs.readFile(path.join(cwd, "angular.json"), "utf-8"));
-    }
-    catch {
-        return FALLBACK;
-    }
-    const projects = cfg?.projects;
-    if (!projects || typeof projects !== "object")
-        return FALLBACK;
-    const firstName = Object.keys(projects)[0];
-    if (!firstName)
-        return FALLBACK;
-    const defaultName = cfg.defaultProject;
-    const projectName = defaultName && projects[defaultName] ? defaultName : firstName;
-    const buildCfg = projects[projectName]?.architect?.build;
-    if (!buildCfg || typeof buildCfg !== "object")
-        return FALLBACK;
-    const opts = (buildCfg.options ?? {});
-    const rawOut = typeof opts === "object" && opts ? opts.outputPath : undefined;
-    let out = typeof rawOut === "string" && rawOut.trim() ? rawOut.trim() : `dist/${projectName}`;
-    if (out.startsWith("./"))
-        out = out.slice(2);
-    const builderId = typeof buildCfg.builder === "string" ? buildCfg.builder : "";
-    const isApplicationBuilder = builderId.endsWith(":application");
-    let browserExists = false;
-    try {
-        browserExists = (await fs.stat(path.join(cwd, out, "browser"))).isDirectory();
-    }
-    catch {
-        // not built locally — rely on the builder-id signal below
-    }
-    return browserExists || isApplicationBuilder ? `${out}/browser` : out;
-}

package/dist/logs.js

@@ -1,4 +1,5 @@
 import chalk from "chalk";
+import { detectMode, emit } from "./agent.js";
 const POLL_INTERVAL_MS = 1500;
 function colorForStream(stream) {
     switch (stream) {
@@ -11,6 +12,11 @@ function colorForStream(stream) {
     }
 }
 export async function streamDeployLogs(api, deployId) {
+    // In JSON mode stdout must stay a clean JSON-lines stream: build logs go
+    // out as structured `build_log` / `stage` events (N2), never as raw text
+    // interleaved with the lifecycle events. In human mode we keep the
+    // coloured stdout + stage banners on stderr.
+    const json = detectMode().json;
     let afterId = 0;
     let lastStage = null;
     // Loop until terminal — the server's per-stage timeouts bound duration.
@@ -19,12 +25,22 @@ export async function streamDeployLogs(api, deployId) {
         const poll = await api.pollLogs(deployId, afterId);
         if (poll.current_stage && poll.current_stage !== lastStage) {
             lastStage = poll.current_stage;
-            process.stderr.write(chalk.bold.blue(`▶ stage: ${poll.current_stage}\n`));
+            if (json) {
+                emit({ event: "stage", name: poll.current_stage });
+            }
+            else {
+                process.stderr.write(chalk.bold.blue(`▶ stage: ${poll.current_stage}\n`));
+            }
         }
         for (const line of poll.lines) {
             afterId = Math.max(afterId, line.id);
-            const paint = colorForStream(line.stream);
-            process.stdout.write(paint(line.line) + "\n");
+            if (json) {
+                emit({ event: "build_log", line: line.line, stream: line.stream });
+            }
+            else {
+                const paint = colorForStream(line.stream);
+                process.stdout.write(paint(line.line) + "\n");
+            }
         }
         if (poll.terminal) {
             return poll;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "layero",
-  "version": "0.7.5",
+  "version": "0.8.1",
   "description": "Layero CLI — publish a local site with one command. No git, no GitHub, agent-friendly (Cursor, Claude Code).",
   "license": "MIT",
   "type": "module",
@@ -49,6 +49,7 @@
     "chalk": "^5.3.0",
     "commander": "^12.1.0",
     "ignore": "^5.3.2",
+    "layero-detection": "^0.1.0",
     "open": "^10.1.0",
     "tar": "^7.4.3"
   },