@treeseed/cli 0.8.13 → 0.8.15

package/dist/cli/handlers/auth-login.js

@@ -7,6 +7,26 @@ import { createMarketClientForInvocation, marketAuthRoot } from "./market-utils.
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function localWebApprovalUrlFromApiUrl(value, profileId) {
+  const explicit = process.env.TREESEED_SITE_URL?.trim() || process.env.BETTER_AUTH_URL?.trim();
+  if (explicit && profileId === "local") {
+    const url2 = new URL(value);
+    return new URL(`${url2.pathname}${url2.search}${url2.hash}`, explicit.replace(/\/+$/u, "")).toString();
+  }
+  const url = new URL(value);
+  if (profileId === "local" && (url.hostname === "127.0.0.1" || url.hostname === "localhost") && url.port === "3000") {
+    url.port = "4321";
+    return url.toString();
+  }
+  return value;
+}
+function approvalUrlForDisplay(value, profileId) {
+  try {
+    return localWebApprovalUrlFromApiUrl(value, profileId);
+  } catch {
+    return value;
+  }
+}
 const handleAuthLogin = async (invocation, context) => {
   try {
     const tenantRoot = marketAuthRoot(context);
@@ -15,8 +35,9 @@ const handleAuthLogin = async (invocation, context) => {
       clientName: "treeseed-cli",
       scopes: ["auth:me", "market"]
     });
+    const approvalUrl = approvalUrlForDisplay(started.verificationUriComplete, profile.id);
     if (context.outputFormat !== "json") {
-      context.write(`Open ${started.verificationUriComplete}`, "stdout");
+      context.write(`Open ${approvalUrl}`, "stdout");
       context.write(`User code: ${started.userCode}`, "stdout");
       context.write("Waiting for approval...", "stdout");
     }

package/dist/cli/handlers/dev.js

@@ -42,6 +42,7 @@ function resolveCoreDevEntrypoint(cwd) {
 }
 const handleDev = async (invocation, context) => {
   try {
+    const managerMode = invocation.commandName === "dev:manager";
     const feedback = typeof invocation.args.feedback === "string" ? invocation.args.feedback : void 0;
     const watch = feedback !== "off";
     const passthroughArgs = [];
@@ -56,8 +57,14 @@ const handleDev = async (invocation, context) => {
         passthroughArgs.push(flag);
       }
     };
-    forwardStringOption("surface", "--surface");
-    forwardStringOption("surfaces", "--surfaces");
+    if (managerMode) {
+      const explicitSurfaces = typeof invocation.args.surfaces === "string" && invocation.args.surfaces.trim() ? invocation.args.surfaces.trim() : typeof invocation.args.surface === "string" && invocation.args.surface.trim() ? invocation.args.surface.trim() : null;
+      const surfaces = explicitSurfaces ?? (invocation.args.withWorker === true ? "manager,worker" : "manager");
+      passthroughArgs.push("--surfaces", surfaces);
+    } else {
+      forwardStringOption("surface", "--surface");
+      forwardStringOption("surfaces", "--surfaces");
+    }
     forwardStringOption("host", "--host");
     forwardStringOption("port", "--port");
     forwardStringOption("apiHost", "--api-host");
@@ -69,6 +76,19 @@ const handleDev = async (invocation, context) => {
     forwardBooleanOption("plan", "--plan");
     forwardBooleanOption("reset", "--reset");
     forwardBooleanOption("json", "--json");
+    const docsAutomationMode = typeof invocation.args.docsAutomation === "string" ? invocation.args.docsAutomation.trim() : "";
+    const workdayId = typeof invocation.args.workdayId === "string" ? invocation.args.workdayId.trim() : "";
+    const capacityBudget = typeof invocation.args.capacityBudget === "string" ? invocation.args.capacityBudget.trim() : "";
+    const approvalPolicy = typeof invocation.args.approvalPolicy === "string" ? invocation.args.approvalPolicy.trim() : "";
+    const devManagerEnv = managerMode ? {
+      TREESEED_DOCS_AUTOMATION_MODE: docsAutomationMode || "on",
+      ...workdayId ? { TREESEED_WORKDAY_ID: workdayId } : {},
+      ...capacityBudget ? {
+        TREESEED_CAPACITY_BUDGET: capacityBudget,
+        TREESEED_WORKDAY_TASK_CREDIT_BUDGET: capacityBudget
+      } : {},
+      TREESEED_APPROVAL_POLICY: approvalPolicy || "manual"
+    } : {};
     const workspaceRoot = findNearestTreeseedWorkspaceRoot(context.cwd);
     const workspaceLinksMode = typeof invocation.args.workspaceLinks === "string" ? invocation.args.workspaceLinks : void 0;
     const workspaceLinks = workspaceRoot ? ensureLocalWorkspaceLinks(workspaceRoot, { env: context.env, mode: workspaceLinksMode }) : null;
@@ -82,7 +102,7 @@ const handleDev = async (invocation, context) => {
       env: resolveTreeseedLaunchEnvironment({
         tenantRoot: context.cwd,
         scope: "local",
-        baseEnv: { ...process.env, ...context.env ?? {} }
+        baseEnv: { ...process.env, ...context.env ?? {}, ...devManagerEnv }
       }),
       stdio: "inherit"
     });
@@ -91,10 +111,18 @@ const handleDev = async (invocation, context) => {
       suppressJsonResult: invocation.args.json === true,
       report: {
         command: "dev",
+        alias: managerMode ? "dev:manager" : invocation.commandName,
         ok: (result.status ?? 1) === 0,
         watch,
         executable: resolved.command,
         args,
+        docsAutomation: managerMode ? {
+          mode: docsAutomationMode || "on",
+          workdayId: workdayId || null,
+          capacityBudget: capacityBudget || null,
+          approvalPolicy: approvalPolicy || "manual",
+          withWorker: invocation.args.withWorker === true
+        } : void 0,
         workspaceLinks
       }
     };

package/dist/cli/handlers/seed.d.ts

@@ -0,0 +1,2 @@
+import type { TreeseedCommandHandler } from '../types.js';
+export declare const handleSeed: TreeseedCommandHandler;

package/dist/cli/handlers/seed.js

@@ -0,0 +1,321 @@
+import { pathToFileURL } from "node:url";
+import { dirname, resolve } from "node:path";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { formatSeedDiagnostics, formatSeedPlan, loadAndPlanSeed } from "@treeseed/sdk/seeds";
+import { MarketApiError } from "@treeseed/sdk/market-client";
+import { createMarketClientForInvocation, marketAuthRoot, marketSelector } from "./market-utils.js";
+import { resolveMarketProfile, resolveMarketSession } from "@treeseed/sdk/market-client";
+async function loadLocalSeedModule(projectRoot) {
+  const apiModulePath = resolve(projectRoot, "src", "lib", "market", "seeds", "local-api.js");
+  const moduleUrl = pathToFileURL(existsSync(apiModulePath) ? apiModulePath : resolve(projectRoot, "src", "lib", "market", "seeds", "apply.js")).href;
+  return await import(moduleUrl);
+}
+function requireLocalSeedSession(invocation, context) {
+  const selector = marketSelector(invocation) ?? "local";
+  const profile = resolveMarketProfile(selector);
+  const session = resolveMarketSession(marketAuthRoot(context), profile.id);
+  if (!session?.accessToken) {
+    throw new Error(`Not logged in to market "${profile.id}". Run treeseed auth:login --market ${profile.id}.`);
+  }
+  return { profile, session };
+}
+function seedRequestBody(invocation) {
+  return {
+    ...typeof invocation.args.environments === "string" ? { environments: invocation.args.environments.split(",").map((entry) => entry.trim()).filter(Boolean) } : {},
+    ...typeof invocation.args.approvalRequest === "string" ? { approvalRequestId: invocation.args.approvalRequest } : {}
+  };
+}
+function planFromRemotePayload(payload) {
+  return {
+    ok: payload.ok !== false,
+    seed: String(payload.seed ?? ""),
+    version: 1,
+    mode: payload.mode === "apply" ? "apply" : "plan",
+    environments: Array.isArray(payload.environments) ? payload.environments : [],
+    summary: payload.summary,
+    actions: Array.isArray(payload.actions) ? payload.actions : [],
+    diagnostics: Array.isArray(payload.diagnostics) ? payload.diagnostics : [],
+    manifestPath: ""
+  };
+}
+function remoteSeedResult(payload, command, exitCode = 0) {
+  const plan = planFromRemotePayload(payload);
+  const result = payload.result && typeof payload.result === "object" ? payload.result : null;
+  return {
+    exitCode,
+    stdout: exitCode === 0 ? [
+      ...formatSeedPlan(plan),
+      ...result ? [
+        "",
+        "Apply:",
+        `  created: ${plan.summary.create}`,
+        `  updated: ${plan.summary.update}`,
+        `  unchanged: ${plan.summary.unchanged}`,
+        `  skipped: ${plan.summary.skip}`,
+        `  failed: ${plan.summary.error}`,
+        ...formatCapacityProviderKeyNotes(result)
+      ] : []
+    ] : [],
+    stderr: exitCode === 0 ? [] : [typeof payload.error === "string" ? payload.error : "Seed operation failed."],
+    report: {
+      ...payload,
+      command,
+      ok: exitCode === 0
+    }
+  };
+}
+function formatCapacityProviderKeyNotes(result) {
+  const capacityProviderKeys = result.capacityProviderKeys && typeof result.capacityProviderKeys === "object" ? result.capacityProviderKeys : null;
+  const created = Array.isArray(capacityProviderKeys?.created) ? capacityProviderKeys.created : [];
+  if (created.length === 0) return [];
+  return [
+    "",
+    "Provider security codes:",
+    ...created.map((entry) => `  ${String(entry.providerName ?? entry.providerKey ?? entry.providerId)} (${String(entry.keyPrefix ?? "new key")}): ${String(entry.plaintextKey ?? "created")}`),
+    "  Copy these now. TreeSeed will not show the plaintext codes again."
+  ];
+}
+function remoteSeedError(error, command) {
+  if (error instanceof MarketApiError) {
+    const payload = error.payload && typeof error.payload === "object" ? error.payload : { error: error.message };
+    const blocked = error.status === 409 || payload.result?.blocked === true;
+    const auth = error.status === 401 || error.status === 403;
+    return remoteSeedResult(payload, command, blocked ? 2 : auth ? 4 : 3);
+  }
+  if (error instanceof Error && /not logged in|authentication|permission denied/iu.test(error.message)) {
+    return {
+      exitCode: 4,
+      stderr: [error.message],
+      report: {
+        command,
+        ok: false,
+        error: error.message
+      }
+    };
+  }
+  throw error;
+}
+function writeSeedExportOutput(context, outputPath, yaml) {
+  const destination = resolve(context.cwd, outputPath);
+  mkdirSync(dirname(destination), { recursive: true });
+  writeFileSync(destination, yaml, "utf8");
+  return destination;
+}
+async function handleSeedExport(invocation, context) {
+  const seedName = invocation.positionals[1];
+  const team = typeof invocation.args.team === "string" ? invocation.args.team.trim() : "";
+  if (!seedName || !team) {
+    return {
+      exitCode: 1,
+      stderr: ["Usage: treeseed seed export <name> --team <team> [--output seeds/exported.yaml]"],
+      report: {
+        command: "seed export",
+        ok: false,
+        error: !seedName ? "Missing required export seed name." : "Missing required --team."
+      }
+    };
+  }
+  const body = {
+    name: seedName,
+    ...typeof invocation.args.environments === "string" ? { environments: invocation.args.environments.split(",").map((entry) => entry.trim()).filter(Boolean) } : {},
+    ...invocation.args.includePrivate === true ? { includePrivate: true } : {},
+    ...invocation.args.includeArtifacts === true ? { includeArtifacts: true } : {}
+  };
+  let payload;
+  try {
+    if (typeof invocation.args.market === "string" || typeof invocation.args.host === "string") {
+      const { client } = createMarketClientForInvocation(invocation, context, { requireAuth: true });
+      payload = await client.exportSeed(team, body);
+    } else {
+      const { session } = requireLocalSeedSession(invocation, context);
+      const localModule = await loadLocalSeedModule(context.cwd);
+      const exporter = localModule.exportLocalSeedViaApiFromCli ?? localModule.exportSeedFromCli;
+      if (typeof exporter !== "function") {
+        throw new Error("Local seed export service is not available in this market project.");
+      }
+      payload = await exporter({
+        projectRoot: context.cwd,
+        seedName,
+        team,
+        environments: typeof invocation.args.environments === "string" ? invocation.args.environments : void 0,
+        includePrivate: invocation.args.includePrivate === true,
+        includeArtifacts: invocation.args.includeArtifacts === true,
+        accessToken: session.accessToken,
+        env: context.env
+      });
+    }
+  } catch (error) {
+    return remoteSeedError(error, "seed export");
+  }
+  const yaml = typeof payload.yaml === "string" ? payload.yaml : "";
+  const outputPath = typeof invocation.args.output === "string" && invocation.args.output.trim() ? invocation.args.output.trim() : null;
+  const writtenPath = outputPath ? writeSeedExportOutput(context, outputPath, yaml) : null;
+  const ok = payload.ok !== false;
+  return {
+    exitCode: ok ? 0 : 1,
+    stdout: context.outputFormat === "json" ? [] : writtenPath ? [`Exported seed ${String(payload.seed ?? seedName)} to ${writtenPath}.`] : yaml.trimEnd().split("\n"),
+    stderr: ok ? [] : ["Seed export failed."],
+    report: {
+      ...payload,
+      command: "seed export",
+      outputPath: writtenPath
+    }
+  };
+}
+const handleSeed = async (invocation, context) => {
+  if (invocation.positionals[0] === "export") {
+    return handleSeedExport(invocation, context);
+  }
+  const seedName = invocation.positionals[0];
+  if (!seedName) {
+    return {
+      exitCode: 1,
+      stderr: ["Usage: treeseed seed <name> [--environments local,staging,prod] [--plan|--validate]"],
+      report: {
+        command: "seed",
+        ok: false,
+        error: "Missing required seed name."
+      }
+    };
+  }
+  const wantsApply = invocation.args.apply === true;
+  const wantsValidate = invocation.args.validate === true;
+  const mode = wantsApply ? "apply" : wantsValidate ? "validate" : "plan";
+  const planned = loadAndPlanSeed({
+    projectRoot: context.cwd,
+    seedName,
+    environments: typeof invocation.args.environments === "string" ? invocation.args.environments : void 0,
+    mode
+  });
+  if (!planned.plan) {
+    return {
+      exitCode: 1,
+      stderr: formatSeedDiagnostics(planned.diagnostics),
+      report: {
+        command: "seed",
+        ok: false,
+        seed: seedName,
+        mode,
+        manifestPath: planned.manifestPath,
+        diagnostics: planned.diagnostics
+      }
+    };
+  }
+  const localAuth = planned.plan.environments.every((environment) => environment === "local") && !wantsValidate ? (() => {
+    try {
+      return requireLocalSeedSession(invocation, context);
+    } catch (error) {
+      return { error };
+    }
+  })() : null;
+  if (localAuth && "error" in localAuth) {
+    return remoteSeedError(localAuth.error, "seed");
+  }
+  if (!wantsApply && !wantsValidate && planned.plan.environments.length === 1 && planned.plan.environments[0] === "local") {
+    try {
+      const localModule = await loadLocalSeedModule(context.cwd);
+      const localPlanner = localModule.planLocalSeedViaApiFromCli ?? localModule.planLocalSeedFromCli;
+      if (typeof localPlanner === "function") {
+        const localPlanned = await localPlanner({
+          projectRoot: context.cwd,
+          seedName,
+          environments: typeof invocation.args.environments === "string" ? invocation.args.environments : void 0,
+          mode,
+          accessToken: localAuth?.session.accessToken,
+          env: context.env
+        });
+        if (localPlanned.plan) {
+          planned.plan = localPlanned.plan;
+        }
+      }
+    } catch (error) {
+      if (error instanceof Error && /not logged in|authentication|permission denied/iu.test(error.message)) {
+        return remoteSeedError(error, "seed");
+      }
+      planned.plan.diagnostics.push({
+        severity: "warning",
+        code: "seed.local_state_unavailable",
+        message: "Local current state could not be loaded; falling back to manifest-only planning.",
+        path: "local"
+      });
+    }
+  }
+  if (wantsApply) {
+    if (planned.plan.environments.some((environment) => environment !== "local")) {
+      try {
+        const { client } = createMarketClientForInvocation(invocation, context, { requireAuth: true });
+        const payload = await client.applySeed(seedName, seedRequestBody(invocation));
+        return remoteSeedResult(payload, "seed");
+      } catch (error) {
+        return remoteSeedError(error, "seed");
+      }
+    }
+    const localModule = await loadLocalSeedModule(context.cwd);
+    const runner = localModule.applyLocalSeedViaApiFromCli ?? localModule.applyLocalSeedFromCli;
+    if (typeof runner !== "function") {
+      throw new Error("Local seed apply service is not available in this market project.");
+    }
+    const applied = await runner({
+      projectRoot: context.cwd,
+      seedName,
+      environments: typeof invocation.args.environments === "string" ? invocation.args.environments : void 0,
+      plan: planned.plan,
+      accessToken: localAuth?.session.accessToken,
+      env: context.env
+    });
+    const message = "Local seed apply completed.";
+    return {
+      exitCode: 0,
+      stdout: context.outputFormat === "json" ? [] : [
+        ...formatSeedPlan(applied.plan),
+        "",
+        "Apply:",
+        `  created: ${applied.plan.summary.create}`,
+        `  updated: ${applied.plan.summary.update}`,
+        `  unchanged: ${applied.plan.summary.unchanged}`,
+        `  skipped: ${applied.plan.summary.skip}`,
+        `  failed: ${applied.plan.summary.error}`,
+        ...formatCapacityProviderKeyNotes(applied.result)
+      ],
+      report: {
+        ...applied.plan,
+        ok: true,
+        command: "seed",
+        result: {
+          message,
+          ...applied.result
+        }
+      }
+    };
+  }
+  if (wantsValidate) {
+    return {
+      exitCode: 0,
+      stdout: [`Seed ${planned.plan.seed} is valid for environments: ${planned.plan.environments.join(", ")}.`],
+      report: {
+        ...planned.plan,
+        command: "seed"
+      }
+    };
+  }
+  if (planned.plan.environments.some((environment) => environment !== "local")) {
+    try {
+      const { client } = createMarketClientForInvocation(invocation, context, { requireAuth: true });
+      const payload = await client.planSeed(seedName, seedRequestBody(invocation));
+      return remoteSeedResult(payload, "seed");
+    } catch (error) {
+      return remoteSeedError(error, "seed");
+    }
+  }
+  return {
+    exitCode: 0,
+    stdout: formatSeedPlan(planned.plan),
+    report: {
+      ...planned.plan,
+      command: "seed"
+    }
+  };
+};
+export {
+  handleSeed
+};

package/dist/cli/operations-registry.js

@@ -30,13 +30,21 @@ const DEV_RUNTIME_OPTIONS = [
   { name: "managerPort", flags: "--manager-port <port>", description: "Port used for the local manager service URL.", kind: "string" },
   { name: "setup", flags: "--setup <mode>", description: "Control automatic local runtime setup.", kind: "enum", values: ["auto", "check", "off"] },
   { name: "feedback", flags: "--feedback <mode>", description: "Control live feedback, service restarts, and browser reload stamps.", kind: "enum", values: ["live", "restart", "off"] },
-  { name: "open", flags: "--open <mode>", description: "Control whether dev opens the browser after readiness.", kind: "enum", values: ["auto", "on", "off"] },
+  { name: "open", flags: "--open <mode>", description: "Control whether dev opens the browser after readiness. Defaults to off; use --open on to launch it.", kind: "enum", values: ["auto", "on", "off"] },
   { name: "plan", flags: "--plan", description: "Print the dev runtime plan and exit without starting services.", kind: "boolean" },
   { name: "reset", flags: "--reset", description: "Clear local dev runtime state before setup, migrations, and service startup.", kind: "boolean" },
   { name: "json", flags: "--json", description: "Emit structured JSON or newline-delimited dev events.", kind: "boolean" },
   { name: "watch", flags: "--watch", description: "Enable live watch behavior. `dev` defaults to live feedback; this remains for compatibility.", kind: "boolean" },
   { name: "workspaceLinks", flags: "--workspace-links <mode>", description: "Control local workspace package links.", kind: "enum", values: ["auto", "off"] }
 ];
+const DEV_MANAGER_OPTIONS = [
+  ...DEV_RUNTIME_OPTIONS,
+  { name: "docsAutomation", flags: "--docs-automation <mode>", description: "Control governed documentation automation for the local manager.", kind: "enum", values: ["on", "dry-run", "off"] },
+  { name: "withWorker", flags: "--with-worker", description: "Run the local worker alongside the manager in the same dev supervisor.", kind: "boolean" },
+  { name: "workdayId", flags: "--workday-id <id>", description: "Start or resume a specific local documentation automation workday.", kind: "string" },
+  { name: "capacityBudget", flags: "--capacity-budget <credits>", description: "Override the local workday task credit budget.", kind: "string" },
+  { name: "approvalPolicy", flags: "--approval-policy <policy>", description: "Set the local docs automation approval policy.", kind: "enum", values: ["manual", "low-risk-auto"] }
+];
 function genericWorkflowPosition(spec) {
   if (spec.group === "Workflow") {
     if (spec.name === "switch") return "start work";
@@ -718,6 +726,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
       longSummary: ["Auth:login authenticates the CLI against the configured Treeseed API so later provider-aware and remote-aware workflows can run without missing-credential failures."],
       examples: [
         example("treeseed auth:login", "Log in with the default host", "Authenticate the CLI against the configured default Treeseed API host."),
+        example("treeseed auth:login --market local", "Log in to local dev", "Authenticate against the local Treeseed API at TREESEED_MARKET_API_BASE_URL or http://127.0.0.1:3000."),
         example("treeseed auth:login --host production", "Target a specific host id", "Override the configured default host for this login session."),
         example("treeseed auth:login --json", "Automate auth workflows", "Emit structured auth results where supported for scripts and agents.")
       ]
@@ -1163,7 +1172,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
   })],
   ["dev", command({
     options: DEV_RUNTIME_OPTIONS,
-    examples: ["treeseed dev", "treeseed dev --reset", "treeseed dev --reset --plan --json", "treeseed dev --surfaces web,api --plan --json", "treeseed dev --surface web --port 4322 --open off"],
+    examples: ["treeseed dev", "treeseed dev --reset", "treeseed dev --reset --plan --json", "treeseed dev --surfaces web,api --plan --json", "treeseed dev --surface web --port 4322"],
     help: {
       longSummary: [
         "Dev starts the unified local Treeseed runtime as a foreground supervisor so you can work against the integrated web, API, manager, worker, and supporting local surfaces.",
@@ -1173,6 +1182,7 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
         "Run from the tenant or workspace root you want to develop.",
         "Use `--plan --json` when you want to inspect selected surfaces, commands, setup steps, readiness checks, watched paths, and restart policy without starting services.",
         "Use `--reset` when you want a fresh local D1 database, Mailpit inbox, generated worker bundle, and Wrangler temp output without deleting configuration.",
+        "Dev prints the local web URL after readiness; it does not open a browser unless you pass `--open on` or `--open auto`.",
         "Keep the foreground process running while you test. Press Ctrl+C to stop the supervised stack and free the local ports."
       ],
       examples: [
@@ -1183,12 +1193,13 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
         example("treeseed dev --surfaces web,api,worker --plan --json", "Inspect selected surfaces", "Plan a comma-separated set of local surfaces without starting the supervisor."),
         example("treeseed dev --surface api --plan --json", "Inspect the API surface", "Plan the local API runtime without the web UI."),
         example("treeseed dev --surfaces integrated,agents", "Opt into agents diagnostics", "Start the integrated local platform plus the agents diagnostic loop."),
-        example("treeseed dev --surface web --port 4322 --open off", "Run only the web surface", "Start the Astro UI on a specific port without opening a browser."),
+        example("treeseed dev --surface web --port 4322", "Run only the web surface", "Start the Astro UI on a specific port and print the URL when ready."),
+        example("treeseed dev --open on", "Open the browser explicitly", "Start the integrated runtime and launch the local web URL after readiness."),
         example("trsd dev", "Use the short alias", "Start the same local runtime through the shorter entrypoint."),
         example("treeseed dev --json", "Stream dev events", "Emit newline-delimited events while the long-running dev process supervises local services.")
       ],
       outcomes: [
-        "Starts the selected local surfaces, waits for readiness, and then remains attached as the live supervisor.",
+        "Starts the selected local surfaces, waits for readiness, prints the local URL, and then remains attached as the live supervisor.",
         "Restarts required crashed surfaces with capped exponential backoff and keeps setup/readiness failures alive for retry.",
         "Stops watchers first and then terminates service process groups when the foreground command exits."
       ]
@@ -1196,6 +1207,27 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
     executionMode: "handler",
     handlerName: "dev"
   })],
+  ["dev:manager", command({
+    options: DEV_MANAGER_OPTIONS,
+    examples: ["treeseed dev:manager", "treeseed dev:manager --with-worker", "treeseed dev:manager --docs-automation dry-run --plan --json"],
+    help: {
+      longSummary: [
+        "Dev:manager starts the governed local documentation automation manager through the same integrated dev supervisor used by `treeseed dev`.",
+        "It selects the manager surface by default, can supervise a local worker with `--with-worker`, and passes docs automation policy into the existing manager and worker runtime."
+      ],
+      examples: [
+        example("treeseed dev:manager", "Start the local manager", "Run the governed workday manager in the foreground."),
+        example("treeseed dev:manager --with-worker", "Start manager plus worker", "Run scheduling and task execution in the same local supervision session."),
+        example("treeseed dev:manager --docs-automation dry-run --plan --json", "Inspect dry-run manager mode", "Show the manager plan and docs automation settings without starting the supervisor.")
+      ],
+      outcomes: [
+        "Starts or plans the existing manager surface, with optional worker supervision.",
+        "Keeps manual approval as the local default and forwards docs automation mode, workday id, capacity budget, and approval policy through runtime environment variables."
+      ]
+    },
+    executionMode: "handler",
+    handlerName: "dev"
+  })],
   ["dev:watch", command({
     options: DEV_RUNTIME_OPTIONS,
     examples: ["treeseed dev:watch", "treeseed dev:watch --json"],
@@ -1265,6 +1297,75 @@ const CLI_COMMAND_OVERLAYS = /* @__PURE__ */ new Map([
   ["starlight:patch", command({ examples: ["treeseed starlight:patch"], executionMode: "adapter" })]
 ]);
 const CLI_ONLY_OPERATION_SPECS = [
+  {
+    id: "seed.plan",
+    name: "seed",
+    aliases: [],
+    group: "Validation",
+    summary: "Validate and plan declarative Treeseed environment seeds.",
+    description: "Load a seed manifest from seeds/<name>.yaml, validate references and environment targeting, produce a deterministic plan, apply governed seeds through the market store/API, or export a team portfolio to YAML.",
+    provider: "default",
+    related: ["status", "config", "capacity", "projects"],
+    usage: "treeseed seed <name> [--environments local,staging,prod] [--plan|--validate|--apply] [--json]\n       treeseed seed export <name> --team <team> [--output <path>] [--json]",
+    arguments: [{ name: "name", description: "Seed manifest name under the project seeds directory, or `export <name>` for portfolio export.", required: true }],
+    options: [
+      { name: "environments", flags: "--environments <list>", description: "Comma-separated environments to select from the manifest.", kind: "string" },
+      { name: "plan", flags: "--plan", description: "Generate a deterministic plan without applying it. This is the Phase 1 default.", kind: "boolean" },
+      { name: "validate", flags: "--validate", description: "Validate the manifest and selected environments without printing plan actions.", kind: "boolean" },
+      { name: "apply", flags: "--apply", description: "Apply local seeds directly or governed staging/production seeds through the market API.", kind: "boolean" },
+      { name: "market", flags: "--market <market>", description: "Market profile or URL for staging and production seed operations.", kind: "string" },
+      { name: "host", flags: "--host <host>", description: "Compatibility alias for --market.", kind: "string" },
+      { name: "approvalRequest", flags: "--approval-request <id>", description: "Approved production seed apply request id.", kind: "string" },
+      { name: "team", flags: "--team <team>", description: "Team slug, name, or id for seed export.", kind: "string" },
+      { name: "output", flags: "--output <path>", description: "Write exported seed YAML to this path.", kind: "string" },
+      { name: "includePrivate", flags: "--include-private", description: "Include private catalog products in seed export when authorized.", kind: "boolean" },
+      { name: "includeArtifacts", flags: "--include-artifacts", description: "Include catalog artifact version references in seed export.", kind: "boolean" },
+      { name: "yes", flags: "--yes", description: "Future-compatible non-interactive confirmation flag for local seed apply.", kind: "boolean" },
+      { name: "strict", flags: "--strict", description: "Reserved for stricter future diagnostics; Phase 1 validation is already strict.", kind: "boolean" },
+      { name: "json", flags: "--json", description: "Emit machine-readable JSON instead of human-readable text.", kind: "boolean" }
+    ],
+    examples: [
+      "treeseed seed treeseed --validate",
+      "treeseed seed treeseed --environments local --plan",
+      "trsd seed treeseed --environments prod --plan --json",
+      "trsd seed export treeseed --team treeseed --include-artifacts --json"
+    ],
+    help: {
+      workflowPosition: "validate",
+      longSummary: [
+        "Seed validates a declarative market portfolio manifest and produces a deterministic reconciliation plan.",
+        "Phase 5 also exports an existing team portfolio into a reusable YAML seed bundle without embedding secrets or artifact bytes."
+      ],
+      whenToUse: [
+        "Use this when a TreeSeed workspace needs a repeatable description of teams, projects, repositories, capacity providers, grants, and work policies.",
+        "Use `--json` when an agent or CI check needs the same plan in a stable machine-readable shape."
+      ],
+      beforeYouRun: [
+        "Run from a Treeseed project containing the requested `seeds/<name>.yaml` manifest.",
+        "Choose the target environments explicitly when reviewing staging or production resources."
+      ],
+      outcomes: [
+        "Prints validation diagnostics, a deterministic plan, an apply summary, or an exported seed manifest.",
+        "Mutates the local market store for local applies, or the selected authenticated market for staging applies and approved production applies."
+      ],
+      automationNotes: [
+        "Agents may run validation and planning safely. Production apply requires an approved seed approval request.",
+        "Skipped resources are omitted from human plan output but included in JSON actions for review."
+      ],
+      warnings: [
+        "Do not put raw secrets in seed manifests; validation rejects secret-looking fields and values.",
+        "`--apply --environments prod` is blocked until a matching approval request is approved."
+      ],
+      relatedDetails: [
+        related("projects", "Use `projects` after Phase 2 apply work lands to inspect created projects through the market API."),
+        related("capacity", "Use `capacity` to inspect existing provider and grant state outside the seed planner.")
+      ]
+    },
+    helpVisible: true,
+    helpFeatured: true,
+    executionMode: "handler",
+    handlerName: "seed"
+  },
   {
     id: "audit.hosting",
     name: "audit",

package/dist/cli/registry.d.ts

@@ -10,6 +10,7 @@ export declare const COMMAND_HANDLERS: {
     readonly status: import("./operations-types.js").TreeseedCommandHandler;
     readonly ci: import("./operations-types.js").TreeseedCommandHandler;
     readonly dev: import("./operations-types.js").TreeseedCommandHandler;
+    readonly 'dev:manager': import("./operations-types.js").TreeseedCommandHandler;
     readonly 'dev:watch': import("./operations-types.js").TreeseedCommandHandler;
     readonly doctor: import("./operations-types.js").TreeseedCommandHandler;
     readonly rollback: import("./operations-types.js").TreeseedCommandHandler;
@@ -40,6 +41,7 @@ export declare const COMMAND_HANDLERS: {
     readonly 'secrets:rotate-passphrase': import("./operations-types.js").TreeseedCommandHandler;
     readonly 'secrets:rotate-machine-key': import("./operations-types.js").TreeseedCommandHandler;
     readonly audit: import("./operations-types.js").TreeseedCommandHandler;
+    readonly seed: import("./operations-types.js").TreeseedCommandHandler;
 };
 export declare const TRESEED_COMMAND_SPECS: TreeseedCommandSpec[];
 export declare function findCommandSpec(name: string | null | undefined): import("./operations-types.js").TreeseedOperationSpec | null;

package/dist/cli/registry.js

@@ -42,6 +42,7 @@ import { handleResume } from "./handlers/resume.js";
 import { handleRecover } from "./handlers/recover.js";
 import { handleWorkspace } from "./handlers/workspace.js";
 import { handleAudit } from "./handlers/audit.js";
+import { handleSeed } from "./handlers/seed.js";
 const workspaceCommand = (name) => `workspace${":"}${name}`;
 const COMMAND_HANDLERS = {
   init: handleInit,
@@ -53,6 +54,7 @@ const COMMAND_HANDLERS = {
   status: handleStatus,
   ci: handleCi,
   dev: handleDev,
+  "dev:manager": handleDev,
   "dev:watch": handleDev,
   doctor: handleDoctor,
   rollback: handleRollback,
@@ -85,7 +87,8 @@ const COMMAND_HANDLERS = {
   "secrets:migrate-key": handleSecretsMigrateKey,
   "secrets:rotate-passphrase": handleSecretsRotatePassphrase,
   "secrets:rotate-machine-key": handleSecretsRotateMachineKey,
-  audit: handleAudit
+  audit: handleAudit,
+  seed: handleSeed
 };
 const TRESEED_COMMAND_SPECS = TRESEED_OPERATION_SPECS;
 function findCommandSpec(name) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@treeseed/cli",
-  "version": "0.8.13",
+  "version": "0.8.15",
   "description": "Operator-facing Treeseed CLI package.",
   "license": "AGPL-3.0-only",
   "repository": {
@@ -31,7 +31,7 @@
     "setup:ci": "npm ci",
     "build": "npm run build:dist",
     "lint": "npm run build:dist",
-    "test": "npm run build:dist && node --test --test-concurrency=1 ./scripts/treeseed-help.test.mjs ./scripts/wrapper-package.test.mjs",
+    "test": "npm run build:dist && node --test --test-concurrency=1 ./scripts/treeseed-help.test.mjs ./scripts/seed.test.mjs ./scripts/wrapper-package.test.mjs",
     "build:dist": "node ./scripts/run-ts.mjs ./scripts/build-dist.ts",
     "prepare": "node ./scripts/prepare.mjs",
     "prepack": "npm run build:dist",
@@ -45,7 +45,7 @@
     "release:publish": "node ./scripts/run-ts.mjs ./scripts/publish-package.ts"
   },
   "dependencies": {
-    "@treeseed/sdk": "0.8.13",
+    "@treeseed/sdk": "0.8.15",
     "ink": "^7.0.0",
     "react": "^19.2.5"
   },