forgeos 0.1.0-alpha.4 → 0.1.0-alpha.40

package/src/forge/cli/last-run.ts

@@ -0,0 +1,84 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+export interface LastRunRecord {
+  schemaVersion: "0.1.0";
+  command: string;
+  ok: boolean;
+  startedAt: string;
+  finishedAt: string;
+  durationMs: number;
+  code?: string;
+  failureKind?: string;
+  message?: string;
+  nextActions: string[];
+  details?: Record<string, unknown>;
+}
+
+export interface LastRunCommandResult {
+  ok: boolean;
+  record: LastRunRecord | null;
+  path: string;
+  exitCode: 0 | 1;
+}
+
+function lastRunPath(workspaceRoot: string): string {
+  return join(workspaceRoot, ".forge", "last-run.json");
+}
+
+export function writeLastRunRecord(workspaceRoot: string, record: LastRunRecord): void {
+  const file = lastRunPath(workspaceRoot);
+  mkdirSync(join(workspaceRoot, ".forge"), { recursive: true });
+  writeFileSync(file, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+}
+
+export function readLastRunRecord(workspaceRoot: string): LastRunRecord | null {
+  const file = lastRunPath(workspaceRoot);
+  if (!existsSync(file)) {
+    return null;
+  }
+  return JSON.parse(readFileSync(file, "utf8")) as LastRunRecord;
+}
+
+export function runLastCommand(options: { workspaceRoot: string }): LastRunCommandResult {
+  const path = lastRunPath(options.workspaceRoot);
+  const record = readLastRunRecord(options.workspaceRoot);
+  return {
+    ok: record !== null,
+    record,
+    path,
+    exitCode: record ? 0 : 1,
+  };
+}
+
+export function formatLastJson(result: LastRunCommandResult): string {
+  return `${JSON.stringify(result, null, 2)}\n`;
+}
+
+export function formatLastHuman(result: LastRunCommandResult): string {
+  if (!result.record) {
+    return `No last run record found at ${result.path}\n`;
+  }
+  const lines = [
+    `Last Forge run: ${result.record.command}`,
+    `OK: ${result.record.ok}`,
+    `Finished: ${result.record.finishedAt}`,
+    `Duration: ${result.record.durationMs}ms`,
+  ];
+  if (result.record.code) {
+    lines.push(`Code: ${result.record.code}`);
+  }
+  if (result.record.failureKind) {
+    lines.push(`Failure: ${result.record.failureKind}`);
+  }
+  if (result.record.message) {
+    lines.push(`Message: ${result.record.message}`);
+  }
+  if (result.record.nextActions.length > 0) {
+    lines.push("Next actions:");
+    for (const action of result.record.nextActions) {
+      lines.push(`  ${action}`);
+    }
+  }
+  return `${lines.join("\n")}\n`;
+}

package/src/forge/cli/main.ts

@@ -4,28 +4,124 @@ import { isMainModule } from "../platform/module.ts";
 import { executeCommand } from "./commands.ts";
 import { hasUnknownOption, parseCli } from "./parse.ts";
 import { formatJsonResult } from "./output.ts";
+import { recordParsedCliCommand } from "../delta/index.ts";
 
 function formatHelp(): string {
   return [
     "ForgeOS",
     "",
     "Start with one of these:",
+    "  forge status --json       Compact project health, handoff state, and next actions",
+    "  forge changed --json      Group changed files into human, generated, and risk buckets",
+    "  forge changed --authored --json  Show only authored changed files, excluding generated artifacts",
+    "  forge changed --review --json  Show review-focused app/config/docs changes, excluding local agent/browser artifacts",
+    "  forge changed --commit-ready --json  Show files suitable for git add, excluding generated and operational artifacts",
+    "  forge new my-app --template minimal-web --field-test  Create an installed WorkOS/auth.md field-test app",
+    "  forge field-test create vendor-access --auth workos --template minimal-web --json  Create a real field-test app",
+    "  forge field-test run --templates minimal-web,nuxt-web --package-managers npm,pnpm --runtime-probes --auth-probes --json",
+    "  forge field-test report --json  Summarize the machine-readable field-test report",
+    "  forge diff authored       Run the authored-only git diff pathspec",
+    "  forge handoff --json      Compact work handoff for the next external code agent",
+    "  forge agent onboard --target codex --json  Prepare adapter, hooks, memory, and dev snapshot",
+    "  forge doctor agent --target codex --json  Check adapter, hooks, and Agent Memory readiness",
+    "  forge doctor delta --json  Check DeltaDB writability, queue drain, redaction, and gitignore posture",
+    "  forge doctor runtime --json  Check generated freshness, local dev lifecycle, and PGlite posture",
+    "  forge agent ingest codex --watch --file .forge/agent/events.ndjson --json",
+    "  forge docs check --json  Check public docs, ReadTheDocs config, links, and local MkDocs tooling",
+    "  forge docs check --build --install-venv --json  Build docs strictly in a local RTD-style venv",
+    "  forge release doctor --json  Check npm publish readiness plus separate production deploy readiness",
+    "  forge authmd generate       Write public/auth.md from the generated agent/auth contract",
+    "  forge auth check --production --json  Fail unless auth is jwt/oidc production-ready",
+    "  forge authmd check --json   Check public/auth.md drift for CI and agent-ready apps",
+    "  forge workos install --yes --json  Delegate AuthKit setup to npx --yes workos@latest install",
+    "  forge workos doctor --json  Check WorkOS AuthKit/FGA files, claims, seed, webhook, and tenant guards",
+    "  forge workos doctor --yes --json  Run local checks, then delegate to npx --yes workos@latest doctor",
+    "  forge workos seed --file workos-seed.yml --dry-run --json  Validate WorkOS seed without hosted changes",
+    "  forge workos setup --real --file workos-seed.yml --json  Apply redirect/CORS/homepage config and seed WorkOS without dashboard",
+    "  forge deploy plan --target docker --json  Explain production deploy gates and commands",
+    "  forge deploy check --production --json  Gate auth, DB, metadata, generated artifacts, and liveQuery readiness",
+    "  forge deploy render docker  Write Docker production deploy files under deploy/",
+    "  forge deploy verify --production --url https://app.example.com --json  Probe /health and validate public auth metadata",
+    "  forge release check --allow-missing-local-release --json  Gate release readiness without failing on unprepared local artifacts",
+    "  forge self-host check --prepared-only --json  Report compose readiness without creating deploy files",
+    "  forge delta status --verbose --json  Include Delta schema, lock, and aggregate count details",
+    "  forge delta compact --json  Compact redacted local agent queue history",
+    "  forge delta prune --older-than 30d --dry-run --json  Plan local Delta operational retention",
+    "  forge delta export --redacted --json  Export redacted Delta status, timeline, and agent memory",
+    "  forge studio open <app-path> --preview-port 5174 --target codex --json",
+    "  forge studio snapshot <app-path> --preview-port 5174 --target codex --probe-codex-server --json",
+    "  forge studio bridge <app-path> --preview-port 5174 --target codex --studio-url http://127.0.0.1:3765 --probe-codex-server --json",
+    "  forge studio doctor <app-path> --preview-port 5174 --target codex --json",
+    "  forge studio codex-server <app-path> --probe --json",
+    "  forge studio watch <app-path> --preview-port 5174 --target codex --json",
     "  forge dev                 Run API, DB/worker, watch, and web app when present",
     "  forge dev --once --json   One-shot health/diagnostic loop for agents and CI",
     "  forge do \"fix\" --json     Ask ForgeOS for the right workflow and commands",
-    "  forge inspect all --json  Read the generated machine contract",
+    "  forge cair snapshot         Compact CAIR project snapshot for agents",
+    "  forge cair query \"Q REFS S#1\"  Run a semantic CAIR query",
+    "  forge cair action --plan \"A RN t=S#1 nn=renamed\"  Plan a guarded semantic edit",
+    "  forge cair action \"A APPLY plan=<P#|path>\"  Apply a guarded CAIR plan",
+    "  forge agent print-context --json  Read the generated agent context pack",
+    "  forge inspect all --brief --json  Read the smallest aggregate project contract",
+    "  forge inspect all --json  Read the compact generated machine contract",
+    "  forge mcp serve          Serve ForgeOS Agent Memory tools over MCP stdio",
+    "  forge agent context --current --json  Read the Agent Memory context pack",
+    "  forge agent timeline --json  Read external-agent hook activity as a compact timeline",
     "  forge doctor windows --json  Diagnose native Windows setup and Bun shims",
+    "  forge bench compiler --json  Measure public compiler phase timings",
+    "  forge manifest validate ./forge.manifest.json --json  Validate an external runtime manifest",
     "",
     "Useful next commands:",
     "  forge generate",
     "  forge check --json",
+    "  forge verify              App-level default verification for the current project",
     "  forge verify --standard",
-    "  forge verify --strict",
+    "  forge verify quick        Alias for smoke/fast local checks",
+    "  forge verify agent        Alias for standard agent-loop verification",
+    "  forge verify release      Alias for strict app release verification",
+    "  forge verify framework    Maintainer-only ForgeOS framework test gate",
+    "  forge verify --strict --typechecker native --test-jobs 6",
+    "  forge verify framework --test-plan --json",
+    "",
+  ].join("\n");
+}
+
+function formatDevHelp(): string {
+  return [
+    "ForgeOS dev",
+    "",
+    "Usage:",
+    "  forge dev [status|stop] [options]",
+    "",
+    "Options:",
+    "  --db memory|pglite|postgres|none  Choose the development database adapter",
+    "  --port <port>                     API runtime port; use 0 for an ephemeral port",
+    "  --web-port <port>                 Web dev server port",
+    "  --host <host>                     Bind host, default 127.0.0.1",
+    "  --no-web                          Start API/runtime only",
+    "  --api-only                        Start API/runtime only",
+    "  --web-only                        Start web server only, expecting an API runtime",
+    "  --no-worker                       Disable local worker",
+    "  --no-watch                        Disable file watching",
+    "  --once --json                     Run one-shot diagnostics without starting servers",
+    "  --detach --json                   Start dev in the background with .forge/dev/dev.pid and .forge/dev/dev.log",
+    "",
+    "Examples:",
+    "  forge dev --db memory --port 3777 --web-port 5174",
+    "  forge dev --db pglite --once --json",
+    "  forge dev --detach --db memory --port 0 --json",
+    "  forge dev status --json",
+    "  forge dev stop --json",
     "",
   ].join("\n");
 }
 
 export async function main(argv: string[] = process.argv.slice(2)): Promise<number> {
+  if (argv[0] === "dev" && (argv.includes("--help") || argv.includes("-h"))) {
+    process.stdout.write(formatDevHelp());
+    return 0;
+  }
+
   if (argv.length === 0 || argv.includes("--help") || argv.includes("-h")) {
     process.stdout.write(formatHelp());
     return 0;
@@ -83,7 +179,15 @@ export async function main(argv: string[] = process.argv.slice(2)): Promise<numb
     return 1;
   }
 
-  return executeCommand(parsed.command);
+  const startedAt = Date.now();
+  const exitCode = await executeCommand(parsed.command);
+  await recordParsedCliCommand({
+    command: parsed.command,
+    argv,
+    exitCode,
+    durationMs: Date.now() - startedAt,
+  });
+  return exitCode;
 }
 
 if (isMainModule(import.meta)) {

package/src/forge/cli/new.ts

@@ -1,6 +1,6 @@
 import { spawn } from "node:child_process";
 import { cpSync, statSync } from "node:fs";
-import { dirname, join, parse, relative, resolve } from "node:path";
+import { basename, dirname, join, parse, relative, resolve } from "node:path";
 import { setTimeout as sleep } from "node:timers/promises";
 import { pathToFileURL } from "node:url";
 import { nodeFileSystem } from "../compiler/fs/index.ts";
@@ -8,7 +8,7 @@ import { run as runGenerate } from "../compiler/orchestrator/run.ts";
 import { resolvePackageManagerArgv } from "../compiler/package-manager/executor.ts";
 import { moduleDir } from "../platform/module.ts";
 
-export type NewTemplateName = "b2b-support-web" | "minimal-web";
+export type NewTemplateName = "agent-workroom" | "b2b-support-web" | "minimal-web" | "nuxt-web";
 export type NewPackageManager = "bun" | "npm" | "pnpm" | "yarn";
 
 export interface NewCommandOptions {
@@ -17,6 +17,7 @@ export interface NewCommandOptions {
   packageManager: NewPackageManager;
   install: boolean;
   git: boolean;
+  fieldTest?: boolean;
   forgePackageSpec?: string;
   localForge?: boolean;
   workspaceRoot: string;
@@ -29,6 +30,11 @@ export interface NewCommandResult {
   packageManager: NewPackageManager;
   installed: boolean;
   gitInitialized: boolean;
+  fieldTest: {
+    requested: boolean;
+    ok: boolean;
+    steps: Array<{ name: string; ok: boolean; command: string }>;
+  };
   generated: boolean;
   gitHygiene: {
     ok: boolean;
@@ -43,9 +49,16 @@ export interface NewCommandResult {
 const REQUIRED_GITIGNORE_PATHS = [
   "src/forge/_generated/",
   "forge.lock",
+  ".codex/",
   ".forge/cache/",
   ".forge/pglite/",
+  ".forge/delta/",
+  ".forge/agent/",
+  ".forge/agent/*.ndjson",
+  ".forge/agent/*.history",
+  ".forge/last-run.json",
   ".forge/local/",
+  ".forge/runtime-cache/",
   ".forge/test-cache/",
   ".forge/test-runs/",
   ".forge/ui-runs/",
@@ -55,6 +68,8 @@ const REQUIRED_GITIGNORE_PATHS = [
   ".forge/reviews/",
   ".forge/impact/",
   ".forge/agent-adapters/",
+  ".forge/studio/",
+  ".workos-seed-state.json",
 ] as const;
 
 const DEFAULT_FORGE_PACKAGE_SPEC = "npm:forgeos@alpha";
@@ -191,12 +206,49 @@ function ensureProjectName(name: string): string | null {
   if (!name.trim()) {
     return "forge new requires a project name";
   }
-  if (name.includes("/") || name.includes("\\") || name === "." || name === "..") {
+  if (name === ".") {
+    return null;
+  }
+  if (name.includes("/") || name.includes("\\") || name === "..") {
     return "project name must be a directory name, not a path";
   }
   return null;
 }
 
+function isCurrentDirectoryTarget(name: string): boolean {
+  return name === ".";
+}
+
+function targetDirectoryFor(options: NewCommandOptions): string {
+  return isCurrentDirectoryTarget(options.name)
+    ? resolve(options.workspaceRoot)
+    : resolve(options.workspaceRoot, options.name);
+}
+
+function sanitizePackageName(name: string): string {
+  return name
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9._-]+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^[._-]+|[._-]+$/g, "") || "forge-app";
+}
+
+function projectNameForTarget(options: NewCommandOptions, targetDir: string): string {
+  return isCurrentDirectoryTarget(options.name)
+    ? sanitizePackageName(basename(targetDir))
+    : options.name;
+}
+
+function blockingExistingEntries(targetDir: string): string[] {
+  const allowed = new Set([".git", ".DS_Store", "Thumbs.db"]);
+  return nodeFileSystem
+    .readDir(targetDir)
+    .map((entry) => entry.name)
+    .filter((name) => !allowed.has(name))
+    .sort();
+}
+
 function analyzeGitHygiene(targetDir: string): NewCommandResult["gitHygiene"] {
   const gitignorePath = join(targetDir, ".gitignore");
   const gitignore = nodeFileSystem.exists(gitignorePath)
@@ -376,6 +428,7 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
       packageManager: options.packageManager,
       installed: false,
       gitInitialized: false,
+      fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
       generated: false,
       gitHygiene: { ok: false, ignoredPaths: [], missingPaths: [] },
       exitCode: 1,
@@ -393,6 +446,7 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
       packageManager: options.packageManager,
       installed: false,
       gitInitialized: false,
+      fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
       generated: false,
       gitHygiene: { ok: false, ignoredPaths: [], missingPaths: [] },
       exitCode: 1,
@@ -401,15 +455,18 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
     };
   }
 
-  const targetDir = resolve(options.workspaceRoot, options.name);
-  if (nodeFileSystem.exists(targetDir)) {
+  const targetDir = targetDirectoryFor(options);
+  const appName = projectNameForTarget(options, targetDir);
+  const currentDirectoryTarget = isCurrentDirectoryTarget(options.name);
+  if (nodeFileSystem.exists(targetDir) && !currentDirectoryTarget) {
     return {
-      name: options.name,
+      name: appName,
       template: options.template,
       targetDir,
       packageManager: options.packageManager,
       installed: false,
       gitInitialized: false,
+      fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
       generated: false,
       gitHygiene: { ok: false, ignoredPaths: [], missingPaths: [] },
       exitCode: 1,
@@ -417,13 +474,32 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
       nextSteps: [],
     };
   }
+  if (nodeFileSystem.exists(targetDir) && currentDirectoryTarget) {
+    const blocking = blockingExistingEntries(targetDir);
+    if (blocking.length > 0) {
+      return {
+        name: appName,
+        template: options.template,
+        targetDir,
+        packageManager: options.packageManager,
+        installed: false,
+        gitInitialized: false,
+        fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
+        generated: false,
+        gitHygiene: { ok: false, ignoredPaths: [], missingPaths: [] },
+        exitCode: 1,
+        message: `current directory is not empty: ${blocking.slice(0, 6).join(", ")}${blocking.length > 6 ? ` (+${blocking.length - 6})` : ""}`,
+        nextSteps: [],
+      };
+    }
+  }
 
   nodeFileSystem.mkdirp(targetDir);
   cpSync(source, targetDir, { recursive: true, force: true });
   ensureGitignore(targetDir);
   replaceTokens(
     targetDir,
-    options.name,
+    appName,
     options.packageManager,
     forgePackageSpec(targetDir, options),
   );
@@ -434,12 +510,13 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
     installed = installCode === 0;
     if (!installed) {
       return {
-        name: options.name,
+        name: appName,
         template: options.template,
         targetDir,
         packageManager: options.packageManager,
         installed,
         gitInitialized: false,
+        fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
         generated: false,
         gitHygiene: analyzeGitHygiene(targetDir),
         exitCode: 1,
@@ -468,12 +545,13 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
     }
     if (!generated) {
       return {
-        name: options.name,
+        name: appName,
         template: options.template,
         targetDir,
         packageManager: options.packageManager,
         installed,
         gitInitialized: false,
+        fieldTest: { requested: Boolean(options.fieldTest), ok: false, steps: [] },
         generated,
         gitHygiene: analyzeGitHygiene(targetDir),
         exitCode: 1,
@@ -489,26 +567,72 @@ export async function runNewCommand(options: NewCommandOptions): Promise<NewComm
     gitInitialized = gitCode === 0;
   }
 
+  const fieldTestSteps: NewCommandResult["fieldTest"]["steps"] = [];
+  if (options.fieldTest && installed) {
+    const steps: Array<{ name: string; command: string; args: string[] }> = [
+      { name: "workos", command: options.packageManager, args: ["run", "forge", "--", "add", "auth", "workos", "--json"] },
+      { name: "generate-workos", command: options.packageManager, args: ["run", "forge", "--", "generate"] },
+      { name: "authmd", command: options.packageManager, args: ["run", "forge", "--", "authmd", "generate", "--json"] },
+      { name: "authmd-check", command: options.packageManager, args: ["run", "forge", "--", "authmd", "check", "--json"] },
+      { name: "workos-doctor", command: options.packageManager, args: ["run", "forge", "--", "workos", "doctor", "--json"] },
+      { name: "workos-seed", command: options.packageManager, args: ["run", "forge", "--", "workos", "seed", "--file", "workos-seed.yml", "--dry-run", "--json"] },
+      { name: "check", command: options.packageManager, args: ["run", "forge", "--", "check", "--json"] },
+    ];
+    for (const step of steps) {
+      const code = await spawnCommand(step.command, step.args, targetDir);
+      fieldTestSteps.push({ name: step.name, ok: code === 0, command: [step.command, ...step.args].join(" ") });
+      if (code !== 0) {
+        break;
+      }
+    }
+    if (gitInitialized && fieldTestSteps.every((step) => step.ok)) {
+      const addCode = await spawnCommand("git", ["add", "-A"], targetDir);
+      const commitCode = addCode === 0
+        ? await spawnCommand("git", [
+          "-c",
+          "user.name=ForgeOS",
+          "-c",
+          "user.email=forgeos@example.invalid",
+          "commit",
+          "-m",
+          "Initial ForgeOS field-test scaffold",
+        ], targetDir)
+        : 1;
+      fieldTestSteps.push({
+        name: "baseline-commit",
+        ok: addCode === 0 && commitCode === 0,
+        command: 'git add -A && git commit -m "Initial ForgeOS field-test scaffold"',
+      });
+    }
+  }
+  const fieldTest = {
+    requested: Boolean(options.fieldTest),
+    ok: !options.fieldTest || (installed && fieldTestSteps.length > 0 && fieldTestSteps.every((step) => step.ok)),
+    steps: fieldTestSteps,
+  };
+
   const nextSteps = [
-    `cd ${options.name}`,
+    ...(currentDirectoryTarget ? [] : [`cd ${options.name}`]),
     ...(installed ? [] : [`${options.packageManager} install`]),
     ...(generated ? [] : [`${options.packageManager} run generate`]),
+    ...(options.fieldTest ? [`${options.packageManager} run forge -- agent onboard --target codex --json`] : []),
     `${options.packageManager} run dev -- --open`,
     `${options.packageManager} run verify`,
   ];
   const gitHygiene = analyzeGitHygiene(targetDir);
 
   return {
-    name: options.name,
+    name: appName,
     template: options.template,
     targetDir,
     packageManager: options.packageManager,
     installed,
     gitInitialized,
+    fieldTest,
     generated,
     gitHygiene,
-    exitCode: 0,
-    message: `Created ${options.name} from template ${options.template}.`,
+    exitCode: fieldTest.ok ? 0 : 1,
+    message: `Created ${appName} from template ${options.template}.`,
     nextSteps,
   };
 }
@@ -520,6 +644,13 @@ export function formatNewHuman(result: NewCommandResult): string {
 
   return [
     result.message,
+    ...(result.fieldTest.requested
+      ? [
+          result.fieldTest.ok
+            ? "Field-test setup completed: WorkOS, auth.md, check, and baseline commit are ready."
+            : `warning: field-test setup did not complete: ${result.fieldTest.steps.find((step) => !step.ok)?.name ?? "not-run"}`,
+        ]
+      : []),
     ...(result.gitHygiene.ok
       ? ["Generated and operational Forge files are ignored by git."]
       : [
@@ -531,3 +662,11 @@ export function formatNewHuman(result: NewCommandResult): string {
     "",
   ].join("\n");
 }
+
+export function formatNewJson(result: NewCommandResult): string {
+  return `${JSON.stringify({
+    schemaVersion: "0.1.0",
+    ok: result.exitCode === 0,
+    ...result,
+  }, null, 2)}\n`;
+}

package/src/forge/cli/next-actions.ts

@@ -0,0 +1,23 @@
+export function uniqueNextActions(actions: string[]): string[] {
+  return [...new Set(actions)].filter(Boolean);
+}
+
+export function releasePrepareNextActions(): string[] {
+  return ["forge release prepare --env production", "forge release check --json"];
+}
+
+export function releaseReadyNextActions(): string[] {
+  return ["forge artifacts verify --json", "forge sourcemaps check --json"];
+}
+
+export function selfHostPrepareNextActions(): string[] {
+  return ["forge self-host compose", "forge self-host env", "forge self-host check --json"];
+}
+
+export function selfHostReadyNextActions(): string[] {
+  return ["docker compose -f deploy/docker-compose.yml config", "forge release prepare --env production"];
+}
+
+export function docsReadyNextActions(): string[] {
+  return ["bun test tests/docs/readthedocs.test.ts", "mkdocs build --strict"];
+}