@standardagents/cli 0.15.3 → 0.16.1-next.1e58032

package/dist/index.js

@@ -6,12 +6,12 @@ import crypto from 'crypto';
 import os3 from 'os';
 import net from 'net';
 import readline from 'readline';
-import { spawn, execSync, spawnSync } from 'child_process';
+import { spawn, execFileSync, spawnSync } from 'child_process';
 import { fileURLToPath, pathToFileURL } from 'url';
-import { FIRST_PARTY_PROVIDER_PACKAGES, renderWranglerJson, renderWorkerIndex, renderDurableThread, renderDurableAgentBuilder, ROOT_CLAUDE_MD, AGENTS_CLAUDE_MD, PROMPTS_CLAUDE_MD, MODELS_CLAUDE_MD, TOOLS_CLAUDE_MD, HOOKS_CLAUDE_MD, API_CLAUDE_MD } from '@standardagents/agentbuilder-template';
+import { FIRST_PARTY_PROVIDER_PACKAGES, AGENT_DEFINITIONS_AGENTS_MD, PROMPTS_AGENTS_MD, MODELS_AGENTS_MD, TOOLS_AGENTS_MD, HOOKS_AGENTS_MD, API_AGENTS_MD, renderAgentBuilderSupportFiles, ROOT_AGENTS_MD } from '@standardagents/agentbuilder-template';
 import chalk from 'chalk';
 import { parse, modify, applyEdits } from 'jsonc-parser';
-import { loadFile, writeFile, generateCode } from 'magicast';
+import { loadFile, writeFile } from 'magicast';
 import { addVitePlugin } from 'magicast/helpers';
 import { useState, useMemo } from 'react';
 import { render, renderToString, Box, Text, useApp, useInput } from 'ink';
@@ -235,30 +235,11 @@ function openBrowser(url) {
     return false;
   }
 }
-function getScaffoldCompatibilityDate() {
-  return "2025-08-13";
-}
 function getScaffoldStandardAgentsVersion() {
   if (process.env.STANDARDAGENTS_WORKSPACE === "1") {
     return "workspace:*";
   }
-  return "0.15.3";
-}
-function getScaffoldCloudflareVitePluginVersion() {
-  return "^1.17.0";
-}
-function getProjectName(cwd) {
-  const packageJsonPath = path7.join(cwd, "package.json");
-  if (fs3.existsSync(packageJsonPath)) {
-    try {
-      const pkg = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
-      if (pkg.name) {
-        return pkg.name.replace(/^@[^/]+\//, "");
-      }
-    } catch {
-    }
-  }
-  return path7.basename(cwd);
+  return "0.16.1-next.1e58032";
 }
 function findViteConfig(cwd) {
   const candidates = ["vite.config.ts", "vite.config.js", "vite.config.mts", "vite.config.mjs"];
@@ -270,16 +251,6 @@ function findViteConfig(cwd) {
   }
   return null;
 }
-function findWranglerConfig(cwd) {
-  const candidates = ["wrangler.jsonc", "wrangler.json"];
-  for (const candidate of candidates) {
-    const configPath = path7.join(cwd, candidate);
-    if (fs3.existsSync(configPath)) {
-      return configPath;
-    }
-  }
-  return null;
-}
 function dependencySectionFor(pkg, packageName, fallback) {
   if (pkg.dependencies?.[packageName] !== void 0) return "dependencies";
   if (pkg.devDependencies?.[packageName] !== void 0) return "devDependencies";
@@ -294,27 +265,20 @@ function setPackageDependency(packageJsonText, section, packageName, version) {
 function updatePackageDependencies(cwd, versions = {}) {
   const packageJsonPath = path7.join(cwd, "package.json");
   if (!fs3.existsSync(packageJsonPath)) {
-    logger.warning("No package.json found. Install @standardagents/builder and @cloudflare/vite-plugin manually.");
+    logger.warning("No package.json found. Install @standardagents/builder manually.");
     return false;
   }
   try {
     const text = fs3.readFileSync(packageJsonPath, "utf-8");
     const pkg = JSON.parse(text);
     const desiredBuilderVersion = versions.standardAgents ?? getScaffoldStandardAgentsVersion();
-    const desiredCloudflareVersion = versions.cloudflareVitePlugin ?? getScaffoldCloudflareVitePluginVersion();
     const builderSection = dependencySectionFor(pkg, "@standardagents/builder", "dependencies");
-    const cloudflareSection = dependencySectionFor(pkg, "@cloudflare/vite-plugin", "devDependencies");
     let result = text;
     let changed = false;
     if (pkg[builderSection]?.["@standardagents/builder"] !== desiredBuilderVersion) {
       result = setPackageDependency(result, builderSection, "@standardagents/builder", desiredBuilderVersion);
       changed = true;
     }
-    const currentAfterBuilder = JSON.parse(result);
-    if (currentAfterBuilder[cloudflareSection]?.["@cloudflare/vite-plugin"] !== desiredCloudflareVersion) {
-      result = setPackageDependency(result, cloudflareSection, "@cloudflare/vite-plugin", desiredCloudflareVersion);
-      changed = true;
-    }
     if (!changed) {
       logger.info("package.json already has current Standard Agents dependencies");
       return true;
@@ -332,28 +296,18 @@ async function modifyViteConfig(configPath, force) {
   try {
     const mod = await loadFile(configPath);
     const code = fs3.readFileSync(configPath, "utf-8");
-    const hasCloudflare = code.includes("@cloudflare/vite-plugin") || code.includes("cloudflare()");
-    const hasAgentBuilder = code.includes("@standardagents/builder") || code.includes("agentbuilder()");
-    if (hasCloudflare && hasAgentBuilder && !force) {
-      logger.info("Vite config already includes Standard Agents plugins");
+    const hasAgentBuilder = code.includes("@standardagents/builder") || code.includes("builder()") || code.includes("agentbuilder()");
+    if (hasAgentBuilder && !force) {
+      logger.info("Vite config already includes builder plugin");
       return true;
     }
     if (!hasAgentBuilder || force) {
       addVitePlugin(mod, {
         from: "@standardagents/builder",
-        imported: "agentbuilder",
-        constructor: "agentbuilder",
-        options: { mountPoint: "/" }
-      });
-      logger.success("Added agentbuilder plugin to vite.config");
-    }
-    if (!hasCloudflare || force) {
-      addVitePlugin(mod, {
-        from: "@cloudflare/vite-plugin",
-        imported: "cloudflare",
-        constructor: "cloudflare"
+        imported: "builder",
+        constructor: "builder"
       });
-      logger.success("Added cloudflare plugin to vite.config");
+      logger.success("Added builder plugin to vite.config");
     }
     await writeFile(mod, configPath);
     return true;
@@ -362,257 +316,42 @@ async function modifyViteConfig(configPath, force) {
     logger.log("");
     logger.log("Please manually add the following to your vite.config.ts:");
     logger.log("");
-    logger.log(`  import { agentbuilder } from '@standardagents/builder'`);
-    logger.log(`  import { cloudflare } from '@cloudflare/vite-plugin'`);
+    logger.log(`  import { builder } from '@standardagents/builder'`);
     logger.log("");
-    logger.log(`  plugins: [agentbuilder({ mountPoint: '/' }), cloudflare()]`);
+    logger.log(`  plugins: [builder()]`);
     logger.log("");
     return false;
   }
 }
-function createOrUpdateWranglerConfig(cwd, projectName, force) {
-  const existingConfig = findWranglerConfig(cwd);
-  if (existingConfig && !force) {
-    try {
-      const text = fs3.readFileSync(existingConfig, "utf-8");
-      const config = parse(text);
-      const hasBindings = config.durable_objects?.bindings?.some(
-        (b) => b.name === "AGENT_BUILDER_THREAD" || b.name === "AGENT_BUILDER"
-      );
-      const hasCodeLoader = config.worker_loaders?.some(
-        (loader) => loader.binding === "AGENT_BUILDER_CODE_LOADER"
-      );
-      const hasCodeCompatibilityDate = config.vars?.AGENT_BUILDER_CODE_COMPATIBILITY_DATE === getScaffoldCompatibilityDate();
-      const hasCtxExportsFlag = Array.isArray(config.compatibility_flags) ? config.compatibility_flags.includes("enable_ctx_exports") : false;
-      if (hasBindings && hasCodeLoader && hasCodeCompatibilityDate && hasCtxExportsFlag) {
-        logger.info("wrangler.jsonc already configured for Standard Agents");
-        return true;
-      }
-      let result = text;
-      if (!hasCodeLoader) {
-        const loaders = [...config.worker_loaders || [], { binding: "AGENT_BUILDER_CODE_LOADER" }];
-        const edits = modify(result, ["worker_loaders"], loaders, {});
-        result = applyEdits(result, edits);
-      }
-      if (!hasCodeCompatibilityDate) {
-        const vars = {
-          ...config.vars || {},
-          AGENT_BUILDER_CODE_COMPATIBILITY_DATE: getScaffoldCompatibilityDate()
-        };
-        const edits = modify(result, ["vars"], vars, {});
-        result = applyEdits(result, edits);
-      }
-      if (!hasCtxExportsFlag) {
-        const flags = Array.isArray(config.compatibility_flags) ? [...config.compatibility_flags, "enable_ctx_exports"] : ["nodejs_compat", "enable_ctx_exports"];
-        const edits = modify(result, ["compatibility_flags"], flags, {});
-        result = applyEdits(result, edits);
-      }
-      if (!config.durable_objects) {
-        const edits = modify(result, ["durable_objects"], {
-          bindings: [
-            { name: "AGENT_BUILDER_THREAD", class_name: "DurableThread" },
-            { name: "AGENT_BUILDER", class_name: "DurableAgentBuilder" }
-          ]
-        }, {});
-        result = applyEdits(result, edits);
-      } else {
-        const bindings = config.durable_objects.bindings || [];
-        if (!bindings.some((b) => b.name === "AGENT_BUILDER_THREAD")) {
-          bindings.push({ name: "AGENT_BUILDER_THREAD", class_name: "DurableThread" });
-        }
-        if (!bindings.some((b) => b.name === "AGENT_BUILDER")) {
-          bindings.push({ name: "AGENT_BUILDER", class_name: "DurableAgentBuilder" });
-        }
-        const edits = modify(result, ["durable_objects", "bindings"], bindings, {});
-        result = applyEdits(result, edits);
-      }
-      if (!config.migrations) {
-        const edits = modify(result, ["migrations"], [
-          { tag: "v1", new_sqlite_classes: ["DurableThread"] },
-          { tag: "v2", new_sqlite_classes: ["DurableAgentBuilder"] }
-        ], {});
-        result = applyEdits(result, edits);
-      }
-      if (!config.main || !config.main.includes("worker")) {
-        const edits = modify(result, ["main"], "worker/index.ts", {});
-        result = applyEdits(result, edits);
-      }
-      if (!config.assets) {
-        const edits = modify(result, ["assets"], {
-          directory: "dist/client",
-          not_found_handling: "single-page-application",
-          binding: "ASSETS",
-          run_worker_first: ["/**"]
-        }, {});
-        result = applyEdits(result, edits);
-      }
-      fs3.writeFileSync(existingConfig, result, "utf-8");
-      logger.success("Updated wrangler.jsonc with Standard Agents configuration");
-      return true;
-    } catch (error) {
-      logger.warning(`Could not update wrangler config: ${error}`);
-      return false;
-    }
-  }
-  const wranglerPath = path7.join(cwd, "wrangler.jsonc");
-  const sanitizedName = projectName.toLowerCase().replace(/[^a-z0-9-]/g, "-");
-  fs3.writeFileSync(
-    wranglerPath,
-    renderWranglerJson({
-      projectName: sanitizedName,
-      compatibilityDate: getScaffoldCompatibilityDate()
-    }),
-    "utf-8"
-  );
-  logger.success("Created wrangler.jsonc");
-  return true;
-}
-function getWorkerEntryPoint(cwd) {
-  const wranglerConfig = findWranglerConfig(cwd);
-  if (wranglerConfig) {
-    try {
-      const text = fs3.readFileSync(wranglerConfig, "utf-8");
-      const config = parse(text);
-      if (config.main) {
-        return path7.join(cwd, config.main);
-      }
-    } catch {
-    }
-  }
-  return path7.join(cwd, "worker", "index.ts");
-}
-async function createOrUpdateWorkerEntry(cwd, force) {
-  const entryPath = getWorkerEntryPoint(cwd);
-  const entryDir = path7.dirname(entryPath);
-  if (!fs3.existsSync(entryDir)) {
-    fs3.mkdirSync(entryDir, { recursive: true });
-    logger.success(`Created ${path7.relative(cwd, entryDir)} directory`);
-  }
-  if (!fs3.existsSync(entryPath)) {
-    fs3.writeFileSync(entryPath, renderWorkerIndex(), "utf-8");
-    logger.success(`Created ${path7.relative(cwd, entryPath)}`);
-    return true;
-  }
-  const content = fs3.readFileSync(entryPath, "utf-8");
-  const hasRouter = content.includes("virtual:@standardagents/builder") && content.includes("router");
-  const hasDurableExports = content.includes("DurableThread") && content.includes("DurableAgentBuilder");
-  const hasCodeBridge = content.includes("CodeExecutionBridge");
-  if (hasRouter && hasDurableExports && hasCodeBridge && !force) {
-    logger.info(`${path7.relative(cwd, entryPath)} already configured`);
-    return true;
-  }
-  if (hasRouter && hasDurableExports && !hasCodeBridge && !force) {
-    fs3.writeFileSync(
-      entryPath,
-      `${content.trimEnd()}
-
-export { CodeExecutionBridge } from "virtual:@standardagents/builder"
-`,
-      "utf-8"
-    );
-    logger.success(`Updated ${path7.relative(cwd, entryPath)} with CodeExecutionBridge export`);
-    return true;
-  }
-  try {
-    const mod = await loadFile(entryPath);
-    if (!content.includes("virtual:@standardagents/builder") || force) {
-      mod.imports.$add({
-        from: "virtual:@standardagents/builder",
-        imported: "router",
-        local: "router"
-      });
-    }
-    if (!content.includes("'../agents/Thread'") || force) {
-      mod.imports.$add({
-        from: "../agents/Thread",
-        imported: "default",
-        local: "DurableThread"
-      });
-    }
-    if (!content.includes("'../agents/AgentBuilder'") || force) {
-      mod.imports.$add({
-        from: "../agents/AgentBuilder",
-        imported: "default",
-        local: "DurableAgentBuilder"
-      });
-    }
-    const { code } = generateCode(mod);
-    if (force || !hasRouter) {
-      fs3.writeFileSync(entryPath, renderWorkerIndex(), "utf-8");
-      logger.success(`Updated ${path7.relative(cwd, entryPath)} with Standard Agents router`);
+function createDirectoriesAndDocs(cwd) {
+  function writeAgentsDocWithClaudeSymlink(dirPath, doc, label) {
+    const agentsDocPath = path7.join(dirPath, "AGENTS.md");
+    const claudeDocPath = path7.join(dirPath, "CLAUDE.md");
+    if (!fs3.existsSync(agentsDocPath)) {
+      fs3.writeFileSync(agentsDocPath, doc, "utf-8");
+      logger.success(`Created ${label}/AGENTS.md`);
     }
-    return true;
-  } catch (error) {
-    if (force) {
-      fs3.writeFileSync(entryPath, renderWorkerIndex(), "utf-8");
-      logger.success(`Created ${path7.relative(cwd, entryPath)}`);
-      return true;
+    if (!fs3.existsSync(claudeDocPath)) {
+      fs3.symlinkSync("AGENTS.md", claudeDocPath);
+      logger.success(`Created ${label}/CLAUDE.md symlink`);
     }
-    logger.warning(`Could not automatically modify ${path7.relative(cwd, entryPath)}`);
-    logger.log("");
-    logger.log("Please ensure your worker entry point includes:");
-    logger.log("");
-    logger.log(`  import { router } from "virtual:@standardagents/builder"`);
-    logger.log(`  import DurableThread from '../agents/Thread';`);
-    logger.log(`  import DurableAgentBuilder from '../agents/AgentBuilder';`);
-    logger.log("");
-    logger.log("  // In your fetch handler:");
-    logger.log("  const res = router(request, env)");
-    logger.log("  if (res) return res");
-    logger.log("");
-    logger.log("  // Export Durable Objects:");
-    logger.log("  export { DurableThread, DurableAgentBuilder }");
-    logger.log('  export { CodeExecutionBridge } from "virtual:@standardagents/builder"');
-    logger.log("");
-    return false;
-  }
-}
-function createDurableObjects(cwd) {
-  const agentsDir = path7.join(cwd, "agents");
-  if (!fs3.existsSync(agentsDir)) {
-    fs3.mkdirSync(agentsDir, { recursive: true });
-  }
-  const threadPath = path7.join(agentsDir, "Thread.ts");
-  if (!fs3.existsSync(threadPath)) {
-    fs3.writeFileSync(threadPath, renderDurableThread(), "utf-8");
-    logger.success("Created agents/Thread.ts");
-  } else {
-    logger.info("agents/Thread.ts already exists");
-  }
-  const agentBuilderPath = path7.join(agentsDir, "AgentBuilder.ts");
-  if (!fs3.existsSync(agentBuilderPath)) {
-    fs3.writeFileSync(agentBuilderPath, renderDurableAgentBuilder(), "utf-8");
-    logger.success("Created agents/AgentBuilder.ts");
-  } else {
-    logger.info("agents/AgentBuilder.ts already exists");
-  }
-}
-function createDirectoriesAndDocs(cwd) {
-  path7.join(cwd, "agents");
-  const rootDocPath = path7.join(cwd, "CLAUDE.md");
-  if (!fs3.existsSync(rootDocPath)) {
-    fs3.writeFileSync(rootDocPath, ROOT_CLAUDE_MD, "utf-8");
-    logger.success("Created CLAUDE.md");
   }
+  writeAgentsDocWithClaudeSymlink(cwd, ROOT_AGENTS_MD, ".");
   const directories = [
-    { path: "agents/agents", doc: AGENTS_CLAUDE_MD },
-    { path: "agents/prompts", doc: PROMPTS_CLAUDE_MD },
-    { path: "agents/models", doc: MODELS_CLAUDE_MD },
-    { path: "agents/tools", doc: TOOLS_CLAUDE_MD },
-    { path: "agents/hooks", doc: HOOKS_CLAUDE_MD },
-    { path: "agents/api", doc: API_CLAUDE_MD }
+    { path: "agents/agents", doc: AGENT_DEFINITIONS_AGENTS_MD },
+    { path: "agents/prompts", doc: PROMPTS_AGENTS_MD },
+    { path: "agents/models", doc: MODELS_AGENTS_MD },
+    { path: "agents/tools", doc: TOOLS_AGENTS_MD },
+    { path: "agents/hooks", doc: HOOKS_AGENTS_MD },
+    { path: "agents/api", doc: API_AGENTS_MD }
   ];
   for (const dir of directories) {
     const dirPath = path7.join(cwd, dir.path);
-    const docPath = path7.join(dirPath, "CLAUDE.md");
     if (!fs3.existsSync(dirPath)) {
       fs3.mkdirSync(dirPath, { recursive: true });
       logger.success(`Created ${dir.path}`);
     }
-    if (!fs3.existsSync(docPath)) {
-      fs3.writeFileSync(docPath, dir.doc, "utf-8");
-      logger.success(`Created ${dir.path}/CLAUDE.md`);
-    }
+    writeAgentsDocWithClaudeSymlink(dirPath, dir.doc, dir.path);
   }
 }
 function updateTsConfig(cwd) {
@@ -627,7 +366,6 @@ function updateTsConfig(cwd) {
     let result = text;
     const types = config.compilerOptions?.types || [];
     const newTypes = [
-      "./worker-configuration.d.ts",
       "./.agents/types.d.ts",
       "./.agents/virtual-module.d.ts"
     ].filter((t) => !types.includes(t));
@@ -637,7 +375,7 @@ function updateTsConfig(cwd) {
       result = applyEdits(result, edits);
     }
     const include = config.include || [];
-    const newIncludes = ["worker", "agents"].filter((i) => !include.includes(i));
+    const newIncludes = ["agents", ".agents", "vite.config.ts"].filter((i) => !include.includes(i));
     if (newIncludes.length > 0) {
       const allIncludes = [...include, ...newIncludes];
       const edits = modify(result, ["include"], allIncludes, {});
@@ -661,9 +399,14 @@ function cleanupViteDefaults(cwd) {
     "src/typescript.svg",
     "src/vite-env.d.ts",
     "index.html",
-    "public/vite.svg"
+    "public/vite.svg",
+    "wrangler.jsonc",
+    "wrangler.json",
+    "worker/index.ts",
+    "agents/Thread.ts",
+    "agents/AgentBuilder.ts"
   ];
-  const dirsToRemove = ["src", "public"];
+  const dirsToRemove = ["src", "public", "worker"];
   for (const file of filesToRemove) {
     const filePath = path7.join(cwd, file);
     if (fs3.existsSync(filePath)) {
@@ -688,7 +431,6 @@ function cleanupViteDefaults(cwd) {
 }
 async function scaffold(options = {}) {
   const cwd = process.cwd();
-  const projectName = getProjectName(cwd);
   const force = options.force || false;
   logger.info("Scaffolding Standard Agents...");
   logger.log("");
@@ -696,12 +438,9 @@ async function scaffold(options = {}) {
   if (viteConfigPath) {
     await modifyViteConfig(viteConfigPath, force);
   } else {
-    logger.warning("No vite.config found. Please create one with cloudflare and agentbuilder plugins.");
+    logger.warning("No vite.config found. Please create one with the agentbuilder plugin.");
   }
   updatePackageDependencies(cwd);
-  createOrUpdateWranglerConfig(cwd, projectName, force);
-  await createOrUpdateWorkerEntry(cwd, force);
-  createDurableObjects(cwd);
   createDirectoriesAndDocs(cwd);
   updateTsConfig(cwd);
   if (force) {
@@ -712,18 +451,17 @@ async function scaffold(options = {}) {
   logger.log("");
   logger.log("Your project structure:");
   logger.log("");
-  logger.log("  CLAUDE.md               # Architecture documentation");
+  logger.log("  AGENTS.md               # Architecture documentation");
+  logger.log("  CLAUDE.md -> AGENTS.md  # Compatibility symlink");
+  logger.log("  vite.config.ts          # Uses builder(); Cloudflare config is generated");
+  logger.log("  tsconfig.json           # Includes agents and generated .agents types");
   logger.log("  agents/");
-  logger.log("  \u251C\u2500\u2500 Thread.ts           # Durable Object for threads");
-  logger.log("  \u251C\u2500\u2500 AgentBuilder.ts     # Durable Object for agent state");
   logger.log("  \u251C\u2500\u2500 agents/             # Agent definitions");
   logger.log("  \u251C\u2500\u2500 prompts/            # Prompt definitions");
   logger.log("  \u251C\u2500\u2500 models/             # Model configurations");
   logger.log("  \u251C\u2500\u2500 tools/              # Custom tools");
   logger.log("  \u251C\u2500\u2500 hooks/              # Lifecycle hooks");
   logger.log("  \u2514\u2500\u2500 api/                # Thread API endpoints");
-  logger.log("  worker/");
-  logger.log("  \u2514\u2500\u2500 index.ts            # Cloudflare Worker entry point");
   logger.log("");
 }
 var STAGE_LABELS = {
@@ -1251,7 +989,6 @@ var GENERATED_STANDARD_AGENTS_PACKAGES = [
   "@standardagents/spec",
   ...FIRST_PARTY_PROVIDER_PACKAGES
 ];
-var PLATFORM_RUNTIME_PACKAGE = "@standardagents/platform-runtime";
 var PACKAGE_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
 var MISSING_PLATFORM_PROJECT_NAME_MESSAGE = "The platform did not return a project name. Please run the init command again to start a new project setup.";
 var LEGACY_BOOTSTRAP_RESPONSE_MESSAGE = "The platform returned an older onboarding response. Please run the init command again to start a new project setup.";
@@ -1458,20 +1195,33 @@ ${details}`));
     child.on("error", reject);
   });
 }
-function runCommandQuiet(command, args, cwd) {
-  return new Promise((resolve, reject) => {
-    const child = spawn(command, args, {
-      cwd,
-      stdio: "ignore",
-      shell: false,
-      detached: true
-    });
-    child.on("error", reject);
-    child.on("spawn", () => {
-      child.unref();
-      resolve();
-    });
+var DEV_SERVER_LOG_FILE = ".agentbuilder-dev.log";
+function startDetachedDevServer(command, args, cwd) {
+  const logPath = path7.join(cwd, DEV_SERVER_LOG_FILE);
+  const logFd = fs3.openSync(logPath, "w");
+  const child = spawn(command, args, {
+    cwd,
+    stdio: ["ignore", logFd, logFd],
+    shell: false,
+    detached: true
   });
+  child.unref();
+  fs3.closeSync(logFd);
+  return { logPath };
+}
+function readLogTail(logPath, maxLines = 20) {
+  try {
+    const text = fs3.readFileSync(logPath, "utf-8").trimEnd();
+    if (!text) return "";
+    return text.split("\n").slice(-maxLines).join("\n");
+  } catch {
+    return "";
+  }
+}
+function devCommandHint(packageManager) {
+  if (packageManager === "npm") return "npm run dev";
+  if (packageManager === "bun") return "bun run dev";
+  return `${packageManager} dev`;
 }
 function canConnectToPort(port) {
   return new Promise((resolve) => {
@@ -1497,17 +1247,17 @@ function buildDevServerCommand(packageManager, port) {
   const viteArgs = ["--host", "127.0.0.1", "--port", String(port), "--strictPort"];
   return packageManager === "npm" ? ["run", "dev", "--", ...viteArgs] : ["dev", ...viteArgs];
 }
-async function waitForLocalDevServer(url) {
-  const deadline = Date.now() + 3e4;
+async function waitForLocalDevServer(url, timeoutMs = 6e4) {
+  const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
     try {
       const response = await fetch(url, { cache: "no-store" });
-      if (response.ok) return;
+      if (response.ok) return true;
     } catch {
     }
     await sleep(500);
   }
-  throw new Error(`Local dev server did not become ready at ${url}`);
+  return false;
 }
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -1540,7 +1290,8 @@ function isStandardAgentsProjectDir(targetPath) {
   if (!fs3.existsSync(agentsDir) || !fs3.statSync(agentsDir).isDirectory()) {
     return false;
   }
-  return hasBuilderDependency(targetPath);
+  if (hasBuilderDependency(targetPath)) return true;
+  return fs3.existsSync(path7.join(targetPath, "vite.config.ts")) && fs3.existsSync(path7.join(targetPath, "tsconfig.json"));
 }
 async function resolveProjectTarget(cwd, initialProjectName, options, promptProjectName = prompt) {
   if (!initialProjectName && isStandardAgentsProjectDir(cwd)) {
@@ -1785,7 +1536,7 @@ async function ensurePlatformAuth(options, quietLogs = false, context = {}) {
   return { connected: true, mode: "standardagents" };
 }
 function getCliVersion() {
-  return "0.15.3";
+  return "0.16.1-next.1e58032";
 }
 function getSipVersion() {
   return "1.0.1";
@@ -1868,18 +1619,14 @@ function validateWorkspacePackageDir(packageName, packageDir) {
     );
   }
 }
-function rewriteStandardAgentsDependenciesForWorkspace(projectPath, workspaceRoot, extraPackageDirs = {}) {
+function rewriteStandardAgentsDependenciesForWorkspace(projectPath, workspaceRoot) {
   const packageJsonPath = path7.join(projectPath, "package.json");
   const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
   const dependencies = packageJson.dependencies ?? {};
   const linkedPackages = [];
-  const packageNames = [
-    ...GENERATED_STANDARD_AGENTS_PACKAGES,
-    ...Object.keys(extraPackageDirs)
-  ];
-  for (const packageName of packageNames) {
+  for (const packageName of GENERATED_STANDARD_AGENTS_PACKAGES) {
     if (!(packageName in dependencies)) continue;
-    const packageDir = extraPackageDirs[packageName] ?? workspacePackageDir(workspaceRoot, packageName);
+    const packageDir = workspacePackageDir(workspaceRoot, packageName);
     validateWorkspacePackageDir(packageName, packageDir);
     dependencies[packageName] = `link:${packageDir}`;
     linkedPackages.push(packageName);
@@ -1891,40 +1638,6 @@ function rewriteStandardAgentsDependenciesForWorkspace(projectPath, workspaceRoo
   }
   return linkedPackages;
 }
-function resolvePlatformRuntimePackageDir() {
-  const explicitRoot = process.env.STANDARDAGENTS_PLATFORM_RUNTIME_ROOT?.trim();
-  if (!explicitRoot) return null;
-  const packageDir = path7.resolve(explicitRoot);
-  validateWorkspacePackageDir(PLATFORM_RUNTIME_PACKAGE, packageDir);
-  return packageDir;
-}
-function addProjectDependency(projectPath, packageName, version) {
-  const packageJsonPath = path7.join(projectPath, "package.json");
-  const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
-  packageJson.dependencies = {
-    ...packageJson.dependencies ?? {},
-    [packageName]: packageJson.dependencies?.[packageName] ?? version
-  };
-  fs3.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
-`, "utf-8");
-}
-function ensurePlatformRuntimeRegistration(projectPath) {
-  const workerIndexPath = path7.join(projectPath, "worker", "index.ts");
-  if (!fs3.existsSync(workerIndexPath)) return false;
-  const source = fs3.readFileSync(workerIndexPath, "utf-8");
-  if (source.includes(`from "${PLATFORM_RUNTIME_PACKAGE}"`) || source.includes(`from '${PLATFORM_RUNTIME_PACKAGE}'`)) {
-    return false;
-  }
-  const registration = [
-    `import { ProviderRegistry } from "@standardagents/builder/runtime"`,
-    `import { createProviderFromEnv } from "${PLATFORM_RUNTIME_PACKAGE}"`,
-    "",
-    "ProviderRegistry.setProviderOverride(createProviderFromEnv)",
-    ""
-  ].join("\n");
-  fs3.writeFileSync(workerIndexPath, `${registration}${source}`, "utf-8");
-  return true;
-}
 function preparePlatformProjectDependencies(projectPath, packageManager) {
   if (process.env.STANDARDAGENTS_WORKSPACE !== "1") {
     return [];
@@ -1936,14 +1649,7 @@ function preparePlatformProjectDependencies(projectPath, packageManager) {
   if (!workspaceRoot) {
     throw new Error("STANDARDAGENTS_WORKSPACE=1 was set, but no Standard Agents workspace root was found");
   }
-  const extraPackageDirs = {};
-  const platformRuntimePackageDir = resolvePlatformRuntimePackageDir();
-  if (platformRuntimePackageDir) {
-    addProjectDependency(projectPath, PLATFORM_RUNTIME_PACKAGE, "workspace:*");
-    ensurePlatformRuntimeRegistration(projectPath);
-    extraPackageDirs[PLATFORM_RUNTIME_PACKAGE] = platformRuntimePackageDir;
-  }
-  return rewriteStandardAgentsDependenciesForWorkspace(projectPath, workspaceRoot, extraPackageDirs);
+  return rewriteStandardAgentsDependenciesForWorkspace(projectPath, workspaceRoot);
 }
 function shellQuote(value) {
   return `"${value.replace(/(["\\$`])/g, "\\$1")}"`;
@@ -2135,6 +1841,43 @@ function resolvePlatformProjectDirectoryName(project, requestedProjectName) {
 function resolvePlatformProjectPackageManager(projectPackageManager, requestedPackageManager) {
   return resolvePackageManager(projectPackageManager ?? void 0, requestedPackageManager);
 }
+function sanitizeGitRemoteUrl(remoteUrl) {
+  try {
+    const url = new URL(remoteUrl);
+    url.username = "";
+    url.password = "";
+    return url.toString();
+  } catch {
+    return remoteUrl.replace(/\/\/[^/@\s]+@/, "//");
+  }
+}
+function cloneDisplayUrl(project) {
+  return project.repo_html_url || sanitizeGitRemoteUrl(project.repo_clone_url);
+}
+function gitCloneArgs(project, projectName) {
+  const args = [];
+  if (project.git_extra_header) {
+    args.push("-c", `http.extraHeader=${project.git_extra_header}`);
+  }
+  args.push("clone", project.repo_clone_url, projectName);
+  return args;
+}
+function platformGitCredentialHelperCommand(cliEntry = process.argv[1] ?? "") {
+  if (process.env.STANDARDAGENTS_WORKSPACE === "1" && cliEntry && fs3.existsSync(cliEntry)) {
+    return `!node ${shellQuote(path7.resolve(cliEntry))} git-credential`;
+  }
+  if (process.env.STANDARD_AGENTS_GIT_HELPER?.trim()) {
+    return process.env.STANDARD_AGENTS_GIT_HELPER.trim();
+  }
+  const cliVersion = getCliVersion();
+  {
+    return `!npx -y @standardagents/cli@${cliVersion} git-credential`;
+  }
+}
+async function configurePlatformGitCredentialHelper(projectPath) {
+  await runCommand("git", ["config", "credential.helper", platformGitCredentialHelperCommand()], projectPath);
+  await runCommand("git", ["config", "credential.useHttpPath", "true"], projectPath);
+}
 function isRetryablePlatformAuthStatus(status) {
   return status === 502 || status === 503 || status === 504;
 }
@@ -2230,6 +1973,71 @@ function upsertEnvLine(lines, key, value) {
 function hasEnvLine(lines, key) {
   return lines.some((line) => line.startsWith(`${key}=`));
 }
+function appendGitignoreEntries(projectPath, heading, entries) {
+  const gitignorePath = path7.join(projectPath, ".gitignore");
+  const gitignoreContent = fs3.existsSync(gitignorePath) ? fs3.readFileSync(gitignorePath, "utf-8") : "";
+  const existingEntries = new Set(gitignoreContent.split(/\r?\n/));
+  const missingEntries = entries.filter((entry) => !existingEntries.has(entry));
+  if (missingEntries.length === 0) return;
+  const prefix = gitignoreContent.length === 0 ? "" : gitignoreContent.endsWith("\n") ? "\n" : "\n\n";
+  fs3.appendFileSync(gitignorePath, `${prefix}${heading}
+${missingEntries.join("\n")}
+`);
+}
+function writeStandardAgentsSupportFiles(projectPath, params) {
+  const written = [];
+  for (const supportFile of renderAgentBuilderSupportFiles({
+    projectName: params.projectName,
+    packageManager: params.packageManager,
+    versions: {
+      standardAgents: getCliVersion(),
+      sip: getSipVersion()
+    }
+  })) {
+    const targetPath = path7.join(projectPath, supportFile.path);
+    if (fs3.existsSync(targetPath)) continue;
+    fs3.mkdirSync(path7.dirname(targetPath), { recursive: true });
+    fs3.writeFileSync(targetPath, supportFile.content, "utf-8");
+    written.push(supportFile.path);
+  }
+  if (written.includes("package.json")) {
+    appendGitignoreEntries(projectPath, "# Standard Agents generated local support files", [
+      "package.json",
+      "package-lock.json",
+      "pnpm-lock.yaml",
+      "yarn.lock",
+      "bun.lock",
+      "bun.lockb",
+      "node_modules"
+    ]);
+  }
+  appendGitignoreEntries(projectPath, "# Standard Agents local dev state", [
+    ".agents",
+    ".wrangler",
+    "dist"
+  ]);
+  return written;
+}
+function supportFiles(options = {}) {
+  let packageManager;
+  try {
+    packageManager = resolvePackageManager(options.packageManager, detectPackageManager());
+  } catch (error) {
+    logger.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+  const cwd = process.cwd();
+  const projectName = normalizeProjectName(options.projectName ?? path7.basename(cwd)) || "standard-agents";
+  const written = writeStandardAgentsSupportFiles(cwd, {
+    projectName,
+    packageManager
+  });
+  if (written.length === 0) {
+    logger.info("Standard Agents local support files already exist");
+    return;
+  }
+  logger.success(`Wrote Standard Agents local support files: ${written.join(", ")}`);
+}
 function writeStandardAgentsEnv(projectPath, params) {
   const envPath = path7.join(projectPath, ".dev.vars");
   const existing = fs3.existsSync(envPath) ? fs3.readFileSync(envPath, "utf-8") : "";
@@ -2258,21 +2066,42 @@ function writeStandardAgentsEnv(projectPath, params) {
   lines = upsertEnvLine(lines, "PLATFORM_ENDPOINT", params.platformEndpoint);
   lines = upsertEnvLine(lines, "STANDARD_AGENTS_API_URL", params.platformEndpoint);
   fs3.writeFileSync(envPath, lines.join("\n").replace(/\n{3,}/g, "\n\n").trim() + "\n", "utf-8");
-  const gitignorePath = path7.join(projectPath, ".gitignore");
-  const gitignoreContent = fs3.existsSync(gitignorePath) ? fs3.readFileSync(gitignorePath, "utf-8") : "";
-  if (!gitignoreContent.split(/\r?\n/).includes(".dev.vars")) {
-    const prefix = gitignoreContent.length === 0 ? "" : gitignoreContent.endsWith("\n") ? "\n" : "\n\n";
-    fs3.appendFileSync(gitignorePath, `${prefix}# Standard Agents local platform token
-.dev.vars
-`);
-  }
+  appendGitignoreEntries(projectPath, "# Standard Agents local platform token", [".dev.vars"]);
   return envPath;
 }
+async function resolveBootstrapProject(endpoint, code, fetchImpl = fetch) {
+  const consumed = await exchangeBootstrapCode(endpoint, code, fetchImpl);
+  const cookie = consumed.session_cookie;
+  const listResponse = await fetchImpl(`${endpoint}/projects`, {
+    headers: { Accept: "application/json", Cookie: cookie }
+  });
+  if (!listResponse.ok) {
+    throw new Error(`Could not load your Standard Agents instance (${listResponse.status}).`);
+  }
+  const listBody = await listResponse.json().catch(() => ({}));
+  const projectId = listBody.projects?.find(
+    (entry) => typeof entry?.id === "string"
+  )?.id;
+  if (!projectId) {
+    throw new Error("No Standard Agents instance found for this account. Create one in the dashboard first.");
+  }
+  const handoffResponse = await fetchImpl(`${endpoint}/projects/${projectId}/cli-handoff`, {
+    method: "POST",
+    headers: { Accept: "application/json", "Content-Type": "application/json", Cookie: cookie },
+    body: "{}"
+  });
+  if (!handoffResponse.ok) {
+    const text = await handoffResponse.text().catch(() => "");
+    throw new Error(`Could not prepare your instance for local setup (${handoffResponse.status})${text ? `: ${text}` : ""}`);
+  }
+  const handoffBody = await handoffResponse.json().catch(() => ({}));
+  if (!handoffBody.project?.repo_clone_url || !handoffBody.project.api_key) {
+    throw new Error("Instance handoff response was missing clone details.");
+  }
+  return handoffBody.project;
+}
 async function runPlatformInit(projectNameArg, options) {
   const cwd = process.cwd();
-  if (options.bootstrap) {
-    logger.warning("Legacy bootstrap codes now continue through browser onboarding.");
-  }
   let pm;
   try {
     pm = resolvePackageManager(options.packageManager, detectPackageManager());
@@ -2286,23 +2115,34 @@ async function runPlatformInit(projectNameArg, options) {
     process.exit(1);
   }
   const endpoint = normalizeApiUrl(options.apiUrl || options.endpoint);
-  logger.info("Opening Standard Agents platform signup/login...");
-  let session;
-  try {
-    session = await startPlatformCliSession({
-      endpoint,
-      projectName: requestedProjectName,
-      packageManager: pm
+  let project;
+  if (options.bootstrap?.trim()) {
+    logger.info("Connecting to your Standard Agents instance...");
+    try {
+      project = await resolveBootstrapProject(endpoint, options.bootstrap.trim());
+    } catch (error) {
+      logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  } else {
+    logger.info("Opening Standard Agents platform signup/login...");
+    let session;
+    try {
+      session = await startPlatformCliSession({
+        endpoint,
+        projectName: requestedProjectName,
+        packageManager: pm
+      });
+    } catch (error) {
+      logger.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+    openUrl(session.auth_url);
+    logger.info("Finish the browser steps. I will stay here and continue automatically.");
+    project = await waitForPlatformProject(session, (progress) => {
+      logger.info(progress.message);
     });
-  } catch (error) {
-    logger.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
   }
-  openUrl(session.auth_url);
-  logger.info("Finish the browser steps. I will stay here and continue automatically.");
-  const project = await waitForPlatformProject(session, (progress) => {
-    logger.info(progress.message);
-  });
   const projectName = resolvePlatformProjectDirectoryName(project, requestedProjectName);
   const projectPackageManager = resolvePlatformProjectPackageManager(project.package_manager, pm);
   const projectPath = path7.join(cwd, projectName);
@@ -2311,28 +2151,77 @@ async function runPlatformInit(projectNameArg, options) {
     process.exit(1);
   }
   logger.success("Browser setup complete.");
-  logger.info(`Cloning ${project.repo_clone_url}...`);
-  await runCommand("git", ["clone", project.repo_clone_url, projectName], cwd);
+  logger.info(`Cloning ${cloneDisplayUrl(project)}...`);
+  await runCommand("git", gitCloneArgs(project, projectName), cwd);
+  if (project.git_extra_header && project.repo_html_url) {
+    await runCommand("git", ["remote", "set-url", "origin", project.repo_html_url], projectPath);
+  }
+  const supportFiles2 = writeStandardAgentsSupportFiles(projectPath, {
+    projectName: project.name || projectName,
+    packageManager: projectPackageManager
+  });
+  if (supportFiles2.length > 0) {
+    logger.success(`Wrote generated local support files: ${supportFiles2.join(", ")}.`);
+  }
   const envPath = writeStandardAgentsEnv(projectPath, {
     apiKey: project.api_key,
     platformEndpoint: endpoint
   });
   logger.success(`Wrote Standard Agents credentials to ${path7.relative(cwd, envPath)}.`);
+  if (project.git_extra_header) {
+    await configurePlatformGitCredentialHelper(projectPath);
+    logger.success("Configured git credentials for the platform repository.");
+  }
   const linkedPackages = preparePlatformProjectDependencies(projectPath, projectPackageManager);
   if (linkedPackages.length > 0) {
     logger.info(`Workspace mode detected: linked ${linkedPackages.length} Standard Agents packages locally.`);
   }
   logger.info(`Installing dependencies with ${projectPackageManager}...`);
   await runCommand(projectPackageManager, ["install"], projectPath);
+  const repoUrl = project.repo_html_url ?? project.repo_clone_url;
+  const tokenLocation = path7.relative(cwd, envPath);
+  if (options.dev === false) {
+    logger.success("Your Standard Agents instance is ready.");
+    logger.log(`Repository:  ${repoUrl}`);
+    logger.log(`Local token: ${tokenLocation}`);
+    logger.log("");
+    logger.log("Start it whenever you like:");
+    logger.log(`  cd ${projectName}`);
+    logger.log(`  ${devCommandHint(projectPackageManager)}`);
+    return;
+  }
   const devPort = await findAvailablePort(5173);
   const devUrl = `http://127.0.0.1:${devPort}`;
   logger.info(`Starting local dev server at ${devUrl}...`);
-  await runCommandQuiet(projectPackageManager, buildDevServerCommand(projectPackageManager, devPort), projectPath);
-  await waitForLocalDevServer(devUrl);
-  openUrl(devUrl);
-  logger.success("Project is connected to Standard Agents.");
-  logger.log(`Repository: ${project.repo_html_url ?? project.repo_clone_url}`);
-  logger.log(`Local token written to ${path7.relative(cwd, envPath)}`);
+  const { logPath } = startDetachedDevServer(
+    projectPackageManager,
+    buildDevServerCommand(projectPackageManager, devPort),
+    projectPath
+  );
+  const ready = await waitForLocalDevServer(devUrl);
+  if (ready) {
+    openUrl(devUrl);
+    logger.success("Project is connected to Standard Agents.");
+    logger.log(`Repository:  ${repoUrl}`);
+    logger.log(`Dev server:  ${devUrl}`);
+    logger.log(`Local token: ${tokenLocation}`);
+    return;
+  }
+  logger.warning(`The dev server didn't respond at ${devUrl} within 60s.`);
+  const tail = readLogTail(logPath);
+  if (tail) {
+    logger.log("");
+    logger.log(`Last dev server output (full log: ${path7.relative(cwd, logPath)}):`);
+    logger.log(tail);
+  }
+  logger.log("");
+  logger.success("Your Standard Agents instance is cloned, configured, and ready.");
+  logger.log(`Repository:  ${repoUrl}`);
+  logger.log(`Local token: ${tokenLocation}`);
+  logger.log("");
+  logger.log("Once any error above is resolved, start it with:");
+  logger.log(`  cd ${projectName}`);
+  logger.log(`  ${devCommandHint(projectPackageManager)}`);
 }
 async function init(projectNameArg, options = {}) {
   if (!options.local) {
@@ -2625,17 +2514,10 @@ export default defineConfig({
   }
   try {
     const installCmd = pm === "npm" ? "install" : "add";
-    const devFlag = pm === "npm" ? "--save-dev" : "-D";
     if (packageSpecifier === "workspace:*") {
       logInfo("Using local workspace @standardagents/* packages (workspace:*).");
     }
     await withTuiSpinner(initTuiMode, "Installing dependencies...", async () => {
-      await runCommand(pm, [
-        installCmd,
-        devFlag,
-        "@cloudflare/vite-plugin",
-        "wrangler"
-      ], projectPath, { quiet: initTuiMode });
       const standardAgentsPackage = (packageName) => `${packageName}@${resolveStandardAgentsPackageSpecifier(packageName, packageSpecifier)}`;
       const deps = [
         standardAgentsPackage("@standardagents/builder"),
@@ -2752,14 +2634,6 @@ export default defineConfig({
       logSuccess("Added .dev.vars to .gitignore");
     }
   }
-  logInfo("Refreshing wrangler type bindings...");
-  try {
-    await withTuiSpinner(initTuiMode, "Generating wrangler types...", async () => {
-      await runCommand("npx", ["wrangler", "types"], projectPath, { quiet: initTuiMode });
-    });
-  } catch (error) {
-    logWarning('Could not generate types automatically. Run "npx wrangler types" manually.');
-  }
   const nextRunCommand = resolvePostInitRunCommand(pm, projectPath, packageSpecifier === "workspace:*");
   if (initTuiMode) {
     clearTerminalScreen();
@@ -2856,8 +2730,19 @@ async function loginWithBootstrap(projectPath, options, fetchImpl = fetch) {
     }
     throw new Error("Bootstrap code required. Run: npx @standardagents/cli login --bootstrap <code>");
   }
+  const state = await consumeBootstrapLogin({ ...options, endpoint, bootstrap: bootstrapCode }, fetchImpl);
+  persistBootstrapState(projectPath, state);
+  syncProjectAuthEnv(projectPath, endpoint, state);
+  return { state, reused: false };
+}
+async function consumeBootstrapLogin(options, fetchImpl = fetch) {
+  const endpoint = resolvePlatformEndpoint({ endpoint: options.endpoint });
+  const bootstrapCode = options.bootstrap?.trim();
+  if (!bootstrapCode) {
+    throw new Error("Bootstrap code required. Run: npx @standardagents/cli login --bootstrap <code>");
+  }
   const consumed = await exchangeBootstrapCode(endpoint, bootstrapCode, fetchImpl);
-  const state = {
+  return {
     version: 1,
     endpoint,
     authenticated_at: Date.now(),
@@ -2865,9 +2750,6 @@ async function loginWithBootstrap(projectPath, options, fetchImpl = fetch) {
     user: consumed.user,
     account: consumed.account
   };
-  persistBootstrapState(projectPath, state);
-  syncProjectAuthEnv(projectPath, endpoint, state);
-  return { state, reused: false };
 }
 async function loginWithPlatform(options) {
   const endpoint = resolvePlatformEndpoint({ endpoint: options.endpoint });
@@ -3050,12 +2932,31 @@ function readCliAuthState() {
     const parsed = JSON.parse(fs3.readFileSync(file, "utf8"));
     return {
       active_org_id: parsed.active_org_id ?? null,
-      orgs: parsed.orgs ?? {}
+      orgs: parsed.orgs ?? {},
+      git_auth: parseCliGitAuthRecord(parsed.git_auth)
     };
   } catch {
     return { active_org_id: null, orgs: {} };
   }
 }
+function parseCliGitAuthRecord(value) {
+  if (!value || typeof value !== "object") return null;
+  const candidate = value;
+  if (candidate.version !== 1) return null;
+  if (typeof candidate.endpoint !== "string" || typeof candidate.session_cookie !== "string" || typeof candidate.account_id !== "string" || typeof candidate.user_id !== "string" || typeof candidate.user_email !== "string" || typeof candidate.updated_at !== "number") {
+    return null;
+  }
+  return {
+    version: 1,
+    endpoint: candidate.endpoint,
+    session_cookie: candidate.session_cookie,
+    account_id: candidate.account_id,
+    account_slug: typeof candidate.account_slug === "string" ? candidate.account_slug : void 0,
+    user_id: candidate.user_id,
+    user_email: candidate.user_email,
+    updated_at: candidate.updated_at
+  };
+}
 function writeCliAuthState(state) {
   ensureStateDir();
   fs3.writeFileSync(stateFilePath(), JSON.stringify(state, null, 2) + "\n", "utf8");
@@ -3064,6 +2965,25 @@ function hasStoredCliAuth() {
   const state = readCliAuthState();
   return Object.keys(state.orgs).length > 0;
 }
+function saveCliGitAuth(input) {
+  const state = readCliAuthState();
+  const record = {
+    version: 1,
+    endpoint: input.endpoint.replace(/\/+$/, ""),
+    session_cookie: input.sessionCookie,
+    account_id: input.account.id,
+    account_slug: input.account.slug,
+    user_id: input.user.id,
+    user_email: input.user.email,
+    updated_at: Date.now()
+  };
+  state.git_auth = record;
+  writeCliAuthState(state);
+  return record;
+}
+function resolveCliGitAuth() {
+  return readCliAuthState().git_auth ?? null;
+}
 function resolveTargetOrgId(state, orgInput) {
   if (orgInput) {
     const trimmed = orgInput.trim();
@@ -3948,14 +3868,14 @@ async function pack(agentName, options) {
       sharedWith: agent.sharedWith
     });
   }
-  for (const prompt4 of analysis.constituents.prompts) {
+  for (const prompt5 of analysis.constituents.prompts) {
     selectionItems.push({
-      name: prompt4.name,
+      name: prompt5.name,
       type: "prompt",
-      filePath: prompt4.filePath,
-      mode: prompt4.sharedWith.length > 0 ? "copy" : "extract",
-      isShared: prompt4.sharedWith.length > 0,
-      sharedWith: prompt4.sharedWith
+      filePath: prompt5.filePath,
+      mode: prompt5.sharedWith.length > 0 ? "copy" : "extract",
+      isShared: prompt5.sharedWith.length > 0,
+      sharedWith: prompt5.sharedWith
     });
   }
   for (const tool of analysis.constituents.tools) {
@@ -4163,349 +4083,74 @@ async function listPacked() {
     console.log("");
   }
 }
-var DEFAULT_ENDPOINT = "https://api.standardagents.ai";
-var FREE_TIER_BUNDLE_LIMIT = 5 * 1024 * 1024;
-function parseEnvFile(content) {
-  const result = {};
-  for (const line of content.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) continue;
-    const eqIndex = trimmed.indexOf("=");
-    if (eqIndex === -1) continue;
-    const key = trimmed.slice(0, eqIndex).trim();
-    let value = trimmed.slice(eqIndex + 1).trim();
-    if (value.startsWith('"') && value.endsWith('"')) {
-      value = value.slice(1, -1).replace(/\\"/g, '"');
-    } else if (value.startsWith("'") && value.endsWith("'")) {
-      value = value.slice(1, -1);
-    }
-    result[key] = value;
-  }
-  return result;
-}
-function compareVersions(a, b) {
-  const [coreA, preA] = a.replace(/^v/, "").split("-", 2);
-  const [coreB, preB] = b.replace(/^v/, "").split("-", 2);
-  const partsA = coreA.split(".").map(Number);
-  const partsB = coreB.split(".").map(Number);
-  for (let i = 0; i < 3; i++) {
-    const va = partsA[i] ?? 0;
-    const vb = partsB[i] ?? 0;
-    if (va < vb) return -1;
-    if (va > vb) return 1;
-  }
-  if (preA && !preB) return -1;
-  if (!preA && preB) return 1;
-  return 0;
-}
-function validateBundleSize(sizeBytes) {
-  if (sizeBytes > FREE_TIER_BUNDLE_LIMIT) {
-    return `Bundle size (${formatBytes(sizeBytes)}) exceeds the free tier limit (${formatBytes(FREE_TIER_BUNDLE_LIMIT)}). A paid plan may be required.`;
-  }
-  return null;
-}
-function createManifest(agents, builderVersion) {
-  return {
-    agents,
-    builder_version: builderVersion
-  };
-}
-function formatBytes(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-function formatDeployError(response) {
-  if (response.error) {
-    return `${response.error.code}: ${response.error.message}`;
-  }
-  if (response.errors && response.errors.length > 0) {
-    return response.errors.join("\n");
+var ARTIFACT_DEPLOY_REMOTE_NAME = "origin";
+function normalizeGitRemoteHost(remote) {
+  try {
+    return new URL(remote).hostname.toLowerCase();
+  } catch {
+    return null;
   }
-  return "Unknown error";
-}
-function detectProject() {
-  const hasWranglerJsonc = fs3.existsSync("wrangler.jsonc") || fs3.existsSync("wrangler.json");
-  const hasAgentsDir = fs3.existsSync("agents/agents");
-  return hasWranglerJsonc || hasAgentsDir;
 }
-function loadEnvFileVars(projectPath) {
-  const envPath = path7.join(projectPath, ".env");
-  if (!fs3.existsSync(envPath)) return {};
-  return parseEnvFile(fs3.readFileSync(envPath, "utf-8"));
+function isStandardAgentsArtifactRemote(remote) {
+  const host = normalizeGitRemoteHost(remote);
+  if (!host) return false;
+  return host === "standardagents.ai" || host.endsWith(".standardagents.ai") || host === "standardagentbuilder.com" || host.endsWith(".standardagentbuilder.com") || host === "artifacts.cloudflare.net" || host.endsWith(".artifacts.cloudflare.net") || host === "artifacts.cloudflare.com" || host.endsWith(".artifacts.cloudflare.com") || host === "git.cloudflare.com";
 }
-function resolveEndpoint(options, envFileVars) {
-  return options.endpoint || process.env.PLATFORM_ENDPOINT || envFileVars.PLATFORM_ENDPOINT || DEFAULT_ENDPOINT;
+function gitOutput(args) {
+  return execFileSync("git", args, {
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"]
+  }).trim();
 }
-function authHeadersForDeploy(auth) {
-  if (auth.kind === "session-cookie") {
-    return { Cookie: auth.cookie };
-  }
-  return { Authorization: `Bearer ${auth.apiKey}` };
-}
-function resolveDeployAuth(options, projectPath = process.cwd()) {
-  const envFileVars = loadEnvFileVars(projectPath);
-  const endpoint = resolveEndpoint(options, envFileVars);
-  if (options.apiKey?.trim()) {
-    return { endpoint, auth: { kind: "api-key", apiKey: options.apiKey.trim() } };
-  }
-  const bootstrap = loadBootstrapState(projectPath);
-  if (bootstrap?.endpoint === endpoint && bootstrap.session_cookie) {
-    return {
-      endpoint,
-      auth: {
-        kind: "session-cookie",
-        cookie: bootstrap.session_cookie
-      }
-    };
-  }
-  const apiKey = process.env.PLATFORM_API_KEY || envFileVars.PLATFORM_API_KEY;
-  if (apiKey) {
-    return { endpoint, auth: { kind: "api-key", apiKey } };
-  }
-  if (bootstrap?.endpoint === endpoint && !bootstrap.session_cookie) {
+function resolveArtifactGitDeployTarget(runner = gitOutput, remoteName = ARTIFACT_DEPLOY_REMOTE_NAME) {
+  const remoteUrl = runner(["remote", "get-url", remoteName]).trim();
+  if (!isStandardAgentsArtifactRemote(remoteUrl)) {
     throw new Error(
-      "Stored org session is from an older CLI version and cannot deploy. Run `agents logout` then `agents login --bootstrap <code>`."
+      `Remote "${remoteName}" is not a Standard Agents Artifacts remote. Deployments now run from pushes to platform-owned repositories.`
     );
   }
-  throw new Error(
-    "No local deploy auth found. Run `agents login --bootstrap <code>` (interactive) or pass --api-key (automation)."
-  );
-}
-function discoverAgents() {
-  const agentsDir = "agents/agents";
-  if (!fs3.existsSync(agentsDir)) return [];
-  const scriptExtensions = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mts", ".mjs"]);
-  const files = fs3.readdirSync(agentsDir).filter((f) => scriptExtensions.has(path7.extname(f)));
-  return files.map((file) => {
-    const filePath = path7.join(agentsDir, file);
-    const realPath = fs3.realpathSync(filePath);
-    if (!realPath.startsWith(fs3.realpathSync("."))) {
-      return path7.basename(file, path7.extname(file));
-    }
-    const content = fs3.readFileSync(filePath, "utf-8");
-    const nameMatch = content.match(/defineAgent\s*\(\s*\{[\s\S]*?\bname\s*:\s*['"]([^'"]+)['"]/);
-    return nameMatch ? nameMatch[1] : path7.basename(file, path7.extname(file));
-  });
-}
-function getBuilderVersion() {
-  const searchPaths = [
-    "node_modules/@standardagents/builder/package.json",
-    "../node_modules/@standardagents/builder/package.json"
-  ];
-  for (const p of searchPaths) {
-    if (fs3.existsSync(p)) {
-      const pkg = JSON.parse(fs3.readFileSync(p, "utf-8"));
-      return pkg.version;
-    }
-  }
-  throw new Error("Could not find @standardagents/builder. Is it installed?");
-}
-function detectPackageManager3() {
-  const userAgent = process.env.npm_config_user_agent;
-  if (userAgent) {
-    if (userAgent.includes("pnpm")) return "pnpm";
-    if (userAgent.includes("yarn")) return "yarn";
-    if (userAgent.includes("bun")) return "bun";
-  }
-  if (fs3.existsSync("pnpm-lock.yaml")) return "pnpm";
-  if (fs3.existsSync("yarn.lock")) return "yarn";
-  if (fs3.existsSync("bun.lockb") || fs3.existsSync("bun.lock")) return "bun";
-  return "npm";
-}
-function buildProject(endpoint) {
-  const pm = detectPackageManager3();
-  const buildCmd = pm === "npm" ? "npx vite build" : `${pm} exec vite build`;
-  execSync(buildCmd, {
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      STANDARD_AGENTS_API_URL: endpoint,
-      PLATFORM_ENDPOINT: endpoint
-    }
-  });
-}
-function findWorkerBundle() {
-  const searchDirs = [".wrangler/tmp", "dist"];
-  for (const dir of searchDirs) {
-    if (!fs3.existsSync(dir)) continue;
-    const bundle = findBundleInDir(dir);
-    if (bundle) return bundle;
+  const branch = runner(["rev-parse", "--abbrev-ref", "HEAD"]).trim();
+  if (!branch || branch === "HEAD") {
+    throw new Error("Cannot deploy from a detached HEAD. Check out a branch before pushing.");
   }
-  throw new Error(
-    "Could not find Worker bundle in build output.\nExpected build output in .wrangler/tmp/ or dist/.\nMake sure `vite build` completed successfully."
-  );
-}
-function findBundleInDir(dir) {
-  const entries = fs3.readdirSync(dir, { withFileTypes: true });
-  const jsFiles = entries.filter((e) => e.isFile() && (e.name.endsWith(".js") || e.name.endsWith(".mjs")));
-  jsFiles.sort((a, b) => {
-    const aIsIndex = a.name === "index.js" || a.name === "index.mjs" ? 0 : 1;
-    const bIsIndex = b.name === "index.js" || b.name === "index.mjs" ? 0 : 1;
-    if (aIsIndex !== bIsIndex) return aIsIndex - bIsIndex;
-    const aSize = fs3.statSync(path7.join(dir, a.name)).size;
-    const bSize = fs3.statSync(path7.join(dir, b.name)).size;
-    return bSize - aSize;
-  });
-  for (const entry of jsFiles) {
-    const fullPath = path7.join(dir, entry.name);
-    const content = fs3.readFileSync(fullPath);
-    if (content.length > 0 && content.toString("utf-8", 0, 1e4).includes("export")) {
-      return { bundlePath: fullPath, bundleContent: content };
-    }
-  }
-  for (const entry of entries) {
-    if (entry.isDirectory() && entry.name !== "client" && entry.name !== "node_modules") {
-      const result = findBundleInDir(path7.join(dir, entry.name));
-      if (result) return result;
-    }
-  }
-  return null;
-}
-async function checkPlatformVersion(endpoint, builderVersion, authHeaders = {}) {
-  const res = await fetch(`${endpoint}/manifest`, { headers: authHeaders });
-  if (!res.ok) {
-    throw new Error(`Failed to check platform version: ${res.status} ${res.statusText}`);
-  }
-  const manifest = await res.json();
-  if (compareVersions(builderVersion, manifest.minimum_builder_version) < 0) {
-    throw new Error(
-      `Builder version ${builderVersion} is below the platform minimum (${manifest.minimum_builder_version}).
-Please upgrade @standardagents/builder:
-  npm install @standardagents/builder@latest`
-    );
-  }
-  return manifest;
+  return {
+    remoteName,
+    remoteUrl,
+    branch,
+    refspec: `HEAD:${branch}`
+  };
 }
-async function uploadDeploy(endpoint, auth, bundleContent, manifest, builderVersion) {
-  const formData = new FormData();
-  formData.append("bundle", new Blob([new Uint8Array(bundleContent)], { type: "application/javascript" }), "index.js");
-  formData.append("manifest", new Blob([JSON.stringify(manifest)], { type: "application/json" }), "manifest.json");
-  formData.append("builder_version", builderVersion);
-  formData.append("agent_count", String(manifest.agents.length));
-  const res = await fetch(`${endpoint}/deploys`, {
-    method: "POST",
-    headers: typeof auth === "string" ? authHeadersForDeploy({ kind: "api-key", apiKey: auth }) : authHeadersForDeploy(auth),
-    body: formData
+function pushArtifactRemote(target) {
+  execFileSync("git", ["push", target.remoteName, target.refspec], {
+    stdio: "inherit"
   });
-  let body;
-  try {
-    body = await res.json();
-  } catch {
-    throw new Error(`Deploy failed (${res.status}): Invalid response from server`);
-  }
-  if (!res.ok) {
-    const errorMsg = formatDeployError(body);
-    throw new Error(`Deploy failed (${res.status}): ${errorMsg}`);
-  }
-  return body;
 }
-async function deploy(options) {
+async function deploy() {
   console.log("");
   logger.info(`${chalk.bold("Standard Agents Deploy")}
 `);
-  if (!detectProject()) {
-    logger.error("This does not appear to be a Standard Agents project.");
-    logger.info("Run this command from a directory with wrangler.jsonc and agents/agents/.");
-    process.exit(1);
-  }
-  let endpoint;
-  let auth;
-  try {
-    ({ endpoint, auth } = resolveDeployAuth(options));
-  } catch (err) {
-    logger.error(err.message);
-    process.exit(1);
-  }
-  logger.success(
-    auth.kind === "session-cookie" ? "Configuration loaded (org-scoped session auth)" : "Configuration loaded (API key auth)"
-  );
-  const agents = discoverAgents();
-  if (agents.length === 0) {
-    const agentsDir = path7.resolve("agents/agents");
-    logger.error(`No deployable agents found in ${agentsDir}.`);
-    if (!fs3.existsSync(agentsDir)) {
-      logger.info("Create agents/agents/ and add at least one file exporting defineAgent(...).");
-    } else {
-      const visibleEntries = fs3.readdirSync(agentsDir).filter((entry) => !entry.startsWith("."));
-      if (visibleEntries.length === 0) {
-        logger.info("agents/agents/ exists but is empty. Add at least one agent file.");
-      } else {
-        const preview = visibleEntries.slice(0, 5).join(", ");
-        const suffix = visibleEntries.length > 5 ? ", ..." : "";
-        logger.info(`Found non-hidden entries in agents/agents/: ${preview}${suffix}`);
-      }
-    }
-    logger.info(`Current working directory: ${process.cwd()}`);
-    logger.info("Run deploy from your project root where agents/agents/ lives.");
-    process.exit(1);
-  }
-  logger.success(`Found ${agents.length} agent${agents.length === 1 ? "" : "s"}: ${agents.join(", ")}`);
-  let builderVersion;
-  try {
-    builderVersion = getBuilderVersion();
-  } catch (err) {
-    logger.error(err.message);
-    process.exit(1);
-  }
-  logger.info(`Builder version: ${builderVersion}`);
-  try {
-    const platformManifest = await checkPlatformVersion(endpoint, builderVersion, authHeadersForDeploy(auth));
-    if (compareVersions(builderVersion, platformManifest.latest_builder_version) < 0) {
-      logger.warning(
-        `A newer builder version is available (${platformManifest.latest_builder_version}). Consider upgrading.`
-      );
-    }
-  } catch (err) {
-    logger.error(err.message);
-    process.exit(1);
-  }
-  logger.info("Building project...\n");
-  try {
-    buildProject(endpoint);
-  } catch {
-    console.log("");
-    logger.error("Build failed. See output above for details.");
-    process.exit(1);
-  }
-  console.log("");
-  logger.success("Build complete");
-  let bundlePath;
-  let bundleContent;
-  try {
-    ({ bundlePath, bundleContent } = findWorkerBundle());
-  } catch (err) {
-    logger.error(err.message);
-    process.exit(1);
-  }
-  const manifest = createManifest(agents, builderVersion);
-  logger.success(`Bundle: ${bundlePath} (${formatBytes(bundleContent.length)})`);
-  const sizeWarning = validateBundleSize(bundleContent.length);
-  if (sizeWarning) {
-    logger.warning(sizeWarning);
-  }
-  logger.info("Uploading...");
+  let target;
   try {
-    const result = await uploadDeploy(endpoint, auth, bundleContent, manifest, builderVersion);
-    console.log("");
-    logger.success(chalk.bold("Deploy successful!"));
-    console.log(`  Deploy ID: ${result.deploy.id}`);
-    console.log(`  Status:    ${result.deploy.status}`);
-    const organizationSlug = result.deploy.organization?.slug ?? result.deploy.org_slug;
-    if (organizationSlug) {
-      console.log(`  URL:       https://${organizationSlug}.standardagents.ai`);
-    }
-    console.log("");
+    target = resolveArtifactGitDeployTarget();
   } catch (err) {
     logger.error(err.message);
+    logger.info("Run this command from a clone created by Standard Agents, or push to the platform git remote manually.");
     process.exit(1);
   }
+  logger.info("Deployments build on the Standard Agents platform from Artifacts git pushes.");
+  logger.log(`Remote: ${target.remoteUrl}`);
+  logger.log(`Branch: ${target.branch}`);
+  logger.log("");
+  pushArtifactRemote(target);
+  logger.success("Push complete. The platform build runner will deploy this commit from the Artifacts push event.");
 }
 var PROJECT_SIGNAL_PATHS = [
   ".agents",
-  "wrangler.jsonc",
-  "worker",
-  "agents"
+  "agents",
+  "vite.config.ts",
+  "vite.config.js",
+  "vite.config.mts",
+  "vite.config.mjs"
 ];
 function hasProjectSignals(cwd) {
   const hits = PROJECT_SIGNAL_PATHS.filter((signal) => fs3.existsSync(path7.join(cwd, signal))).length;
@@ -4568,7 +4213,7 @@ function getHomeActions(context) {
     {
       id: "deploy",
       label: "Deploy",
-      description: "Build and deploy this linked project to StandardAgents.",
+      description: "Push this linked project to StandardAgents for a platform build.",
       argv: ["deploy"]
     },
     {
@@ -4924,7 +4569,7 @@ function isOpaqueModelId(modelId) {
 function getProviderDefinition(name) {
   return PROVIDER_DEFINITIONS.find((provider) => provider.name === name);
 }
-function parseEnvFile2(content) {
+function parseEnvFile(content) {
   const result = {};
   for (const line of content.split("\n")) {
     const trimmed = line.trim();
@@ -5028,7 +4673,7 @@ function loadProjectEnv(projectRoot, processEnv = process.env) {
   for (const fileName of envFiles) {
     const filePath = path7.join(projectRoot, fileName);
     if (!fs3.existsSync(filePath)) continue;
-    Object.assign(result, parseEnvFile2(fs3.readFileSync(filePath, "utf8")));
+    Object.assign(result, parseEnvFile(fs3.readFileSync(filePath, "utf8")));
   }
   for (const [key, value] of Object.entries(processEnv)) {
     if (typeof value === "string") {
@@ -5279,6 +4924,224 @@ async function availableModels(options = {}) {
     writeError(message);
   }
 }
+function parseKeyValueLines(input) {
+  const result = {};
+  for (const line of input.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const index = line.indexOf("=");
+    if (index <= 0) continue;
+    result[line.slice(0, index)] = line.slice(index + 1);
+  }
+  return result;
+}
+function findDotDevVars(startDir = process.cwd()) {
+  let current = path7.resolve(startDir);
+  while (true) {
+    const candidate = path7.join(current, ".dev.vars");
+    if (fs3.existsSync(candidate)) return candidate;
+    const parent = path7.dirname(current);
+    if (parent === current) return null;
+    current = parent;
+  }
+}
+function normalizeEndpoint(value) {
+  return value.replace(/\/+$/, "");
+}
+function normalizeGitHost(host) {
+  return host.trim().toLowerCase().replace(/:\d+$/, "");
+}
+function isStandardAgentsGitHost(host) {
+  const normalized = normalizeGitHost(host);
+  return normalized === "standardagents.ai" || normalized.endsWith(".standardagents.ai") || normalized === "standardagentbuilder.com" || normalized.endsWith(".standardagentbuilder.com") || normalized === "artifacts.cloudflare.net" || normalized.endsWith(".artifacts.cloudflare.net") || normalized === "artifacts.cloudflare.com" || normalized.endsWith(".artifacts.cloudflare.com") || normalized === "git.cloudflare.com";
+}
+function loadLocalConfig(options) {
+  const envPath = findDotDevVars(options.startDir);
+  const fileVars = envPath ? parseKeyValueLines(fs3.readFileSync(envPath, "utf-8")) : {};
+  const endpoint = normalizeEndpoint(
+    options.endpoint || process.env.STANDARD_AGENTS_API_URL || process.env.PLATFORM_ENDPOINT || fileVars.STANDARD_AGENTS_API_URL || fileVars.PLATFORM_ENDPOINT || ""
+  );
+  const apiKey = process.env.STANDARD_AGENTS_API_KEY || fileVars.STANDARD_AGENTS_API_KEY || "";
+  if (endpoint && apiKey) {
+    return { endpoint, auth: { kind: "api-key", apiKey } };
+  }
+  const cookie = process.env.STANDARD_AGENTS_SESSION_COOKIE || process.env.STANDARDAGENTS_BOOTSTRAP_SESSION_COOKIE || fileVars.STANDARDAGENTS_BOOTSTRAP_SESSION_COOKIE || "";
+  if (endpoint && cookie) {
+    return { endpoint, auth: { kind: "session-cookie", cookie } };
+  }
+  const globalAuth = resolveCliGitAuth();
+  if (!globalAuth) return null;
+  const requestedEndpoint = endpoint || normalizeEndpoint(options.endpoint || "");
+  if (requestedEndpoint && requestedEndpoint !== globalAuth.endpoint) {
+    return null;
+  }
+  return {
+    endpoint: globalAuth.endpoint,
+    auth: { kind: "session-cookie", cookie: globalAuth.session_cookie }
+  };
+}
+function remoteFromCredentialRequest(request) {
+  if (!request.protocol || !request.host) return null;
+  if (!isStandardAgentsGitHost(request.host)) return null;
+  const repoPath = request.path ? `/${request.path.replace(/^\/+/, "")}` : "";
+  return `${request.protocol}://${normalizeGitHost(request.host)}${repoPath}`;
+}
+async function readStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+async function gitCredential(operation, options = {}) {
+  if (operation !== "get") return;
+  const config = loadLocalConfig(options);
+  if (!config) return;
+  const input = options.input ?? await readStdin();
+  const remote = remoteFromCredentialRequest(parseKeyValueLines(input));
+  if (!remote) return;
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const headers = {
+    "Content-Type": "application/json"
+  };
+  if (config.auth.kind === "api-key") {
+    headers.Authorization = `Bearer ${config.auth.apiKey}`;
+  } else {
+    headers.Cookie = config.auth.cookie;
+  }
+  const response = await fetchImpl(`${config.endpoint}/projects/git-token`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({ remote, scope: "write" })
+  }).catch(() => null);
+  if (!response?.ok) return;
+  const body = await response.json().catch(() => null);
+  const tokenSecret = body?.artifact_git?.token_secret;
+  if (!tokenSecret) return;
+  const write = options.write ?? ((text) => {
+    process.stdout.write(text);
+  });
+  write(`username=x
+password=${tokenSecret}
+
+`);
+}
+var DEFAULT_GIT_HELPER_COMMAND = "!npx -y @standardagents/cli@latest git-credential";
+function prompt4(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function defaultGitRunner(args) {
+  const result = spawnSync("git", args, { encoding: "utf8" });
+  return {
+    status: result.status,
+    stdout: result.stdout || "",
+    stderr: result.stderr || ""
+  };
+}
+function runGit(args, runner) {
+  const result = runner(args);
+  if (result.status !== 0) {
+    throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+  }
+  return result;
+}
+function configureStandardAgentsGitCredentials(options = {}) {
+  const runner = options.gitRunner ?? defaultGitRunner;
+  const helperCommand = options.helperCommand?.trim() || process.env.STANDARD_AGENTS_GIT_HELPER || DEFAULT_GIT_HELPER_COMMAND;
+  const existing = runGit(["config", "--global", "--get-all", "credential.helper"], runner).stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  let helperAdded = false;
+  if (!existing.includes(helperCommand)) {
+    runGit(["config", "--global", "--add", "credential.helper", helperCommand], runner);
+    helperAdded = true;
+  }
+  runGit(["config", "--global", "credential.useHttpPath", "true"], runner);
+  return { helperCommand, helperAdded };
+}
+async function completeBrowserGitLogin(options, endpoint) {
+  let authAppUrl = resolvePlatformAuthBrowserUrl(endpoint);
+  let sessionId = null;
+  let wsUrl = null;
+  let wsExpiresAt = 0;
+  try {
+    const started = await startCliAuthSession(endpoint);
+    sessionId = started.session_id;
+    authAppUrl = started.auth_url;
+    wsUrl = started.ws_url;
+    wsExpiresAt = started.expires_at;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Failed to start realtime auth session";
+    logger.warning(`${message} Switching to manual bootstrap command entry.`);
+  }
+  logger.log(`Auth app: ${authAppUrl}`);
+  if (options.open !== false) {
+    const opened = openBrowser(authAppUrl);
+    if (opened) {
+      logger.info("Opened browser for authentication.");
+    } else {
+      logger.warning("Could not automatically open browser. Open the URL above manually.");
+    }
+  }
+  if (wsUrl && wsExpiresAt > 0) {
+    try {
+      const completion = await waitForCliAuthCompletion(wsUrl, wsExpiresAt);
+      return consumeBootstrapLogin({ ...options, endpoint, bootstrap: completion.bootstrapCode });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Realtime auth handoff failed";
+      logger.warning(`${message} Enter bootstrap code manually to continue.`);
+    }
+  }
+  if (!process.stdin.isTTY) {
+    throw new Error("Non-interactive shell detected. Run: npx @standardagents/cli git-login --bootstrap <code>");
+  }
+  const input = await prompt4("Bootstrap code or command: ");
+  const bootstrapCode = parseBootstrapCodeInput(input);
+  if (!bootstrapCode) {
+    if (sessionId) {
+      await cancelCliAuthSession(endpoint, sessionId);
+    }
+    throw new Error("No bootstrap code provided. Run: npx @standardagents/cli git-login --bootstrap <code>");
+  }
+  if (sessionId) {
+    await cancelCliAuthSession(endpoint, sessionId);
+  }
+  return consumeBootstrapLogin({ ...options, endpoint, bootstrap: bootstrapCode });
+}
+async function gitLogin(options = {}) {
+  const endpoint = resolvePlatformEndpoint({ endpoint: options.endpoint });
+  logger.log("");
+  logger.info("Starting Standard Agents Git authentication...");
+  logger.log(`Platform API: ${endpoint}`);
+  const state = options.bootstrap?.trim() ? await consumeBootstrapLogin({ ...options, endpoint, bootstrap: options.bootstrap.trim() }) : await completeBrowserGitLogin(options, endpoint);
+  if (!state.session_cookie) {
+    throw new Error("Platform login did not return a session cookie for Git authentication.");
+  }
+  const record = saveCliGitAuth({
+    endpoint,
+    sessionCookie: state.session_cookie,
+    account: state.account,
+    user: state.user
+  });
+  let configured = null;
+  if (options.config !== false) {
+    configured = configureStandardAgentsGitCredentials(options);
+  }
+  logger.log("");
+  logger.success("Git authentication configured.");
+  logger.log(`Account: ${record.account_id}${record.account_slug ? ` (${record.account_slug})` : ""}`);
+  logger.log(`User: ${record.user_email}`);
+  if (configured) {
+    logger.log(`Credential helper: ${configured.helperCommand}${configured.helperAdded ? "" : " (already installed)"}`);
+  }
+  logger.log("");
+}
 
 // src/index.ts
 async function settleStdinForInitHandoff(stdin = process.stdin) {
@@ -5299,8 +5162,8 @@ async function settleStdinForInitHandoff(stdin = process.stdin) {
   }
 }
 var program = new Command();
-program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.15.3");
-program.command("init [project-name]").description("Create a new Standard Agents project").option("-y, --yes", "Skip prompts and use defaults").option("--local", "Use local project scaffolding instead of browser platform onboarding").option("--cli", "Use classic line-by-line CLI prompts instead of the TUI wizard").option("--api-url <url>", "Standard Agents platform API URL").option("--endpoint <url>", "Platform API endpoint for auth/bootstrap exchange").option("--package-manager <manager>", "Package manager for generated project: npm, pnpm, yarn, or bun").option("--template <template>", "Vite template to use", "vanilla-ts").option("--workspace", "Install @standardagents packages as workspace:* (local pnpm workspace development)").addOption(new Option("--bootstrap <code>", "Exchange a web onboarding bootstrap code")).action(init);
+program.name("agents").description("CLI tool for Standard Agents / AgentBuilder").version("0.16.1-next.1e58032");
+program.command("init [project-name]").description("Create a new Standard Agents project").option("-y, --yes", "Skip prompts and use defaults").option("--local", "Use local project scaffolding instead of browser platform onboarding").option("--cli", "Use classic line-by-line CLI prompts instead of the TUI wizard").option("--api-url <url>", "Standard Agents platform API URL").option("--endpoint <url>", "Platform API endpoint for auth/bootstrap exchange").option("--package-manager <manager>", "Package manager for generated project: npm, pnpm, yarn, or bun").option("--template <template>", "Vite template to use", "vanilla-ts").option("--workspace", "Install @standardagents packages as workspace:* (local pnpm workspace development)").option("--no-dev", "Clone and configure the project without starting the dev server").addOption(new Option("--bootstrap <code>", "Exchange a web onboarding bootstrap code")).action(init);
 program.command("login").description("Authenticate this machine (or use --bootstrap for project bootstrap auth)").option("--bootstrap <code>", "Bootstrap code from web onboarding").option("--endpoint <url>", "Platform API endpoint (default: https://api.standardagents.ai)").option("--no-open", "Do not auto-open browser URL").action(login);
 program.command("logout").description("Clear stored StandardAgents auth and local org-scoped project auth").option("--org <org-id-or-slug>", "Org ID or slug to logout (defaults to active org)").option("--endpoint <url>", "Platform API endpoint (default: https://api.standardagents.ai)").action(logout);
 program.command("scaffold").description("Add Standard Agents to an existing Vite project").option("--force", "Overwrite existing configuration").action(scaffold);
@@ -5308,7 +5171,10 @@ program.command("init-chat [project-name]").description("Scaffold a frontend cha
 program.command("pack [agent-name]").description("Pack an agent with all its dependencies").option("--output <dir>", "Output directory (default: agents/packed)").option("--npm", "Generate npm-ready package structure").option("--version <version>", "Package version (default: 1.0.0)").option("--no-remove", "Keep original files after packing").option("--no-interactive", "Skip interactive item mode selector").action(pack);
 program.command("unpack [package]").description("Unpack a packed agent to the local agents directory").option("--no-signatures", "Remove package signatures (fully editable)").action(unpack);
 program.command("list-packed").description("List all discovered packed agents").action(listPacked);
-program.command("deploy").description("Build and deploy your project to the Standard Agents platform").option("--api-key <key>", "Platform API key (overrides STANDARD_AGENTS_API_KEY env var)").option("--endpoint <url>", "Platform API endpoint (default: https://api.standardagents.ai)").action(deploy);
+program.command("deploy").description("Push the current branch to the Standard Agents Artifacts remote").action(deploy);
+program.command("git-credential <operation>").description("Git credential helper for Standard Agents platform repositories").option("--endpoint <url>", "Platform API endpoint").action(gitCredential);
+program.command("git-login").description("Authenticate Git for Standard Agents platform repositories").option("--bootstrap <code>", "Bootstrap code from web onboarding").option("--endpoint <url>", "Platform API endpoint (default: https://api.standardagents.ai)").option("--helper-command <command>", "Credential helper command to add to global git config").option("--no-config", "Store Git auth but do not update global git config").option("--no-open", "Do not auto-open browser URL").action(gitLogin);
+program.command("support-files").description("Write generated local support files for a Standard Agents platform repository").option("--project-name <name>", "Project name to use in the generated package manifest").option("--package-manager <manager>", "Package manager: npm, pnpm, yarn, or bun").action(supportFiles);
 program.command("skill").description("Install the bundled AgentBuilder guidance into a supported coding agent").option("--agent <target>", "Install target: codex or claude").option("--dir <path>", "Install directory override for the selected target").option("--force", "Overwrite an existing installed skill").action(skill);
 program.command("current-models").description("Print the live curated model guide from standardagentspec.com").option("--url <url>", "Override the models markdown URL").action(currentModels);
 program.command("available-models").description("List every available model for one configured provider in the current project").option("--provider <provider>", "Provider to query, for example cerebras or openai").action(availableModels);