aui-agent-builder 0.3.137 → 0.3.139

package/README.md

@@ -160,11 +160,24 @@ aui logout                       # Clear session and credentials
 ```bash
 aui agents                       # Interactive menu: list, create, switch, import, delete
 aui agents --list                # List all agents in the current account
-aui agents --create              # Interactive creation (org → account → name)
+aui agents --create              # Create, then auto-import into ./<agent-name> and drop you in
 aui agents --switch              # Switch the active agent in your session
 aui agents --delete              # Interactive: org → account → agent → choose scope (whole / one version / all versions)
 ```
 
+**`aui agents --create` is end-to-end.** It creates the agent + its first
+version, **auto-imports it into a new `./<agent-name>` folder** (use `--dir
+<path>` to override), and **drops you into that folder via an interactive
+subshell** so you can start editing immediately — run `exit` to return. The
+creation **mode follows your environment**: `staging` / `custom` → bundle mode,
+`production` / `eu-production` → records mode. Override with `--bundle-mode` /
+`--records-mode`. **Non-interactive creation is create-only:** `--json`,
+piped output, CI, and the agent-builder-bff sandbox skip BOTH the auto-import
+and the subshell and behave like a plain create (set `AUI_AUTO_IMPORT=1` to
+force the import in automation; `AUI_AUTO_IMPORT=0` to disable it in a
+terminal). A child process can't change the parent shell's cwd, which is why
+the interactive case opens a nested shell.
+
 **Non-interactive creation:**
 
 ```bash
@@ -177,8 +190,12 @@ aui agents --create --name "My Agent" --account-id <id>
 # With a specific category (e.g. Amazon, Google Flights)
 aui agents --create --name "My Agent" --account-id <id> --category Amazon
 
-# Create + v1.0 draft (ready to import, edit, and push)
-aui agents --create --name "My Agent" --account-id <id> --draft
+# Import the new agent into a specific folder instead of ./<agent-name>
+aui agents --create --name "My Agent" --account-id <id> --dir ./my-agent
+
+# Force a creation mode regardless of environment
+aui agents --create --name "My Agent" --account-id <id> --records-mode
+aui agents --create --name "My Agent" --account-id <id> --bundle-mode
 
 # One-step: create + version + publish + activate
 aui agents --create --name "My Agent" --account-id <id> --full
@@ -511,25 +528,26 @@ aui upgrade                               # Update to latest version
 ### Create and Deploy a New Agent
 
 ```bash
-# Step 1: Create the agent (with a v1.0 draft ready to edit)
-aui agents --create --name "Support Agent" --account-id <id> --draft
-
-# Step 2: Import as local files
-aui import-agent
+# Step 1: Create the agent. This also auto-imports it into ./support-agent
+# and drops you into that folder via an interactive subshell — no separate
+# `aui import-agent` needed. (Use --dir to choose a different folder.)
+aui agents --create --name "Support Agent" --account-id <id>
 
-# Step 3: Edit configuration in your editor
-cd ./support-agent
+# Step 2: Edit configuration in your editor (you're already in the folder)
 # → Edit agent.aui.json, tools/*.aui.json, parameters.aui.json, etc.
 
-# Step 4: Validate and push
+# Step 3: Validate and push
 aui validate
 aui push
 
-# Step 5: Publish and activate
+# Step 4: Publish and activate
 aui version publish
 aui version activate
 ```
 
+> Prefer the classic two-step flow? It still works: create with `--json`
+> (which skips the auto-import/subshell), then run `aui import-agent` yourself.
+
 **Creation modes:**
 
 ```bash

package/dist/commands/agents.d.ts

@@ -28,6 +28,14 @@ export interface AgentsOptions {
     draft?: boolean;
     name?: string;
     category?: string;
+    /**
+     * After `--create`, auto-import the freshly created agent's latest
+     * draft into this directory. When omitted, the import targets the
+     * current working directory (`.`). Only the records-mode `--create`
+     * flow produces a v1.0 draft to import; bundle-mode / template
+     * creates skip the auto-import (nothing to snapshot yet).
+     */
+    dir?: string;
     networkId?: string;
     accountId?: string;
     switch?: boolean;

package/dist/commands/agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/commands/agents.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAkCH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA8ED,wBAAsB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CAgyDvE;AAuQD;;;;GAIG;AACH;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;;;;OAKG;IACH,IAAI,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IAC9B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,QAAQ,GAAE,2BAAgC,GACzC,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAuIxD"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/commands/agents.tsx"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAoCH,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;;;;;;OAQG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;;OAMG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;;;;;;;;;OAaG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB;AA8ED,wBAAsB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,CA6zDvE;AAuaD;;;;GAIG;AACH;;;;;GAKG;AACH,MAAM,WAAW,2BAA2B;IAC1C;;;;;OAKG;IACH,IAAI,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;IAC9B;;;;;;;OAOG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,iBAAiB,EAAE,MAAM,EACzB,QAAQ,GAAE,2BAAgC,GACzC,OAAO,CAAC;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAAC,CAuIxD"}

package/dist/commands/agents.js

@@ -1,4 +1,6 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { spawnSync } from "child_process";
+import * as path from "path";
 import { render, Box, Text } from "ink";
 import inquirer from "inquirer";
 import chalk from "chalk";
@@ -1096,15 +1098,20 @@ export async function agents(options = {}) {
         //
         // Defaults when nothing is passed:
         //   - kind        → "regular"
-        //   - bundle_mode → false  (records mode). `aui agents --create`
-        //                           auto-creates a v1.0 draft from the agent
-        //                           scope (`source=agent-scope`), which is
-        //                           records-mode only. A fresh bundle-mode
-        //                           agent has nothing to snapshot, so making
-        //                           bundle-mode the default broke `--create`
-        //                           (and left an un-importable agent behind).
-        //                           Opt into blob-mode explicitly with
-        //                           `--bundle-mode`.
+        //   - bundle_mode → ENVIRONMENT-DRIVEN (resolved just below where
+        //                   `bundleMode` is computed):
+        //                     • production / eu-production → false (records
+        //                       mode — the legacy per-entity flow still used
+        //                       in prod).
+        //                     • staging / custom           → true (bundle
+        //                       mode). `custom` is the staging-v3 backend,
+        //                       mapped to staging, so it shares the default.
+        //                   Records-mode regulars auto-snapshot a v1.0 draft
+        //                   from agent-scope; bundle-mode regulars are
+        //                   provisioned end-to-end via the Apollo endpoint
+        //                   (version cloned from a template). Both then
+        //                   auto-import locally. Override either way with
+        //                   `--bundle-mode` / `--records-mode`.
         if (opts.bundleMode && opts.recordsMode) {
             renderView(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "error", label: "--bundle-mode and --records-mode are mutually exclusive." }), _jsx(Text, { color: "gray", children: "  Pick one — or pass neither to use the default (records-mode)." })] }));
             return;
@@ -1129,10 +1136,32 @@ export async function agents(options = {}) {
             return;
         }
         const kind = opts.template ? "template" : "regular";
-        // Templates ALWAYS bundle-mode. For regulars, records-mode is the
-        // default (so the auto-draft flow can snapshot from agent-scope);
-        // --bundle-mode opts into blob-mode.
-        const bundleMode = opts.template ? true : opts.bundleMode === true;
+        // ─── Resolve bundle_mode ──────────────────────────────────────────
+        //
+        // Precedence (highest first):
+        //   1. Templates                 → always bundle-mode (forced).
+        //   2. Explicit --bundle-mode    → bundle-mode.
+        //   3. Explicit --records-mode   → records-mode.
+        //   4. Otherwise (no flag)       → derived from the signed-in
+        //                                  environment (see below).
+        //
+        // Environment-driven default for regulars when neither flag is passed:
+        //   - production / eu-production → records-mode (bundle_mode=false).
+        //     Prod still runs on the legacy per-entity records flow.
+        //   - staging / custom          → bundle-mode (bundle_mode=true).
+        //     NOTE: `custom` is the staging-v3 backend — it's mapped to
+        //     staging, so it gets the same bundle-mode default as staging.
+        //
+        // Override either way with --bundle-mode / --records-mode explicitly.
+        const env = config.environment ?? "staging";
+        const envDefaultsToBundle = !(env === "production" || env === "eu-production");
+        const bundleMode = opts.template
+            ? true
+            : opts.bundleMode === true
+                ? true
+                : opts.recordsMode === true
+                    ? false
+                    : envDefaultsToBundle;
         const client = new AUIClient({
             baseUrl: config.apiUrl,
             authToken: config.authToken,
@@ -1241,12 +1270,13 @@ export async function agents(options = {}) {
             // publish → activate) to the Apollo provisioning endpoint. The
             // legacy per-step path below is records-mode only.
             if (bundleMode) {
-                await createBundledAgentViaApollo({
+                const created = await createBundledAgentViaApollo({
                     name: agentName,
                     networkCategoryId: categoryId,
                     organizationId: client.getOrganizationId(),
                     accountId: client.getAccountId(),
                 });
+                await autoImportAndEnter(created, opts.dir, agentName);
                 return;
             }
             const netSpinner = render(_jsx(Spinner, { label: "Creating agent..." }));
@@ -1383,12 +1413,13 @@ export async function agents(options = {}) {
         // single call, so we skip the legacy per-step path (network create →
         // createAgentOnBackend → draft/full flow) entirely.
         if (bundleMode) {
-            await createBundledAgentViaApollo({
+            const created = await createBundledAgentViaApollo({
                 name: agentName,
                 networkCategoryId: categoryId || "",
                 organizationId: client.getOrganizationId(),
                 accountId: client.getAccountId(),
             });
+            await autoImportAndEnter(created, opts.dir, agentName);
             return;
         }
         // Create network
@@ -1421,18 +1452,18 @@ export async function agents(options = {}) {
             bundleMode,
         });
         if (result && opts.full) {
-            await runFullFlow(result.agentId, bundleMode);
+            await runFullFlow(result.agentId, bundleMode, opts.dir, agentName);
         }
         else if (result) {
             // Draft is the DEFAULT: `aui agents --create` always creates a v1.0
             // draft version, even without `--draft`. The `--draft` flag is kept
             // as an explicit (now redundant) way to ask for the same thing.
             // Use `--full` to also publish + activate in one step.
-            await runDraftFlow(result.agentId, bundleMode);
+            await runDraftFlow(result.agentId, bundleMode, opts.dir, agentName);
         }
     }
 }
-async function runDraftFlow(agentId, bundleMode = false) {
+async function runDraftFlow(agentId, bundleMode = false, dir, agentName) {
     // Bundle-mode (blob) agents can't seed a draft from agent-scope, and a
     // brand-new one has no version to clone from either. Skip the auto-draft
     // and tell the user how to seed it instead of failing with a mode error.
@@ -1448,9 +1479,159 @@ async function runDraftFlow(agentId, bundleMode = false) {
     });
     if (!draft)
         return;
-    logView(_jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [_jsxs(Box, { children: [_jsx(Text, { color: "green", bold: true, children: "✓ " }), _jsx(Text, { bold: true, children: "Draft v1.0 created. Next steps:" })] }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { children: "    " }), _jsx(Text, { backgroundColor: "cyan", color: "black", bold: true, children: " 1 " }), _jsx(Text, { bold: true, children: "  aui import-agent           " }), _jsx(Text, { color: "gray", children: "Download the agent locally" })] }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { children: "    " }), _jsx(Text, { backgroundColor: "cyan", color: "black", bold: true, children: " 2 " }), _jsx(Text, { bold: true, children: "  aui push                   " }), _jsx(Text, { color: "gray", children: "Push your edits" })] }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { children: "    " }), _jsx(Text, { backgroundColor: "cyan", color: "black", bold: true, children: " 3 " }), _jsx(Text, { bold: true, children: "  aui version publish         " }), _jsx(Text, { color: "gray", children: "Lock the version" })] }), _jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { children: "    " }), _jsx(Text, { backgroundColor: "cyan", color: "black", bold: true, children: " 4 " }), _jsx(Text, { bold: true, children: "  aui version activate        " }), _jsx(Text, { color: "gray", children: "Go live" })] }), _jsx(Text, { children: " " })] }));
+    logView(_jsx(StatusLine, { kind: "success", label: "Draft v1.0 created." }));
+    // Auto-import the freshly created draft so the user lands in a ready-to-
+    // edit local project without a separate `aui import-agent` step. Defaults
+    // to a new `./<agent-name>` folder; `--dir` overrides the destination.
+    const importedDir = await autoImportLatestDraft(agentId, {
+        versionId: draft.id,
+        dir,
+        agentName,
+    });
+    // Drop the user straight into the new project so they can start working
+    // right away (no manual `cd`). No-op when there's no interactive TTY.
+    if (importedDir)
+        enterProjectShell(importedDir);
 }
-async function runFullFlow(agentId, bundleMode = false) {
+/**
+ * Auto-"cd" the user into the freshly imported project by launching an
+ * interactive subshell rooted in that directory — the same pattern used by
+ * `poetry shell`, `nix-shell`, etc. A child process cannot mutate its
+ * parent shell's cwd, so spawning a nested shell is the only way to leave
+ * the user actually sitting inside the new folder, ready to work.
+ *
+ * `dir` MUST be an absolute path — the caller resolves it BEFORE returning
+ * so we don't re-resolve a relative path against an already-changed cwd
+ * (the bug that left users stuck in the original directory).
+ *
+ * Strictly interactive-only and best-effort:
+ *   - Skipped unless BOTH stdin and stdout are TTYs (so the agent-builder-bff
+ *     sandbox, pipes, and CI never get trapped in a shell that nothing can
+ *     `exit`).
+ *   - Any spawn failure is swallowed — the import already succeeded, and the
+ *     files are sitting in `dir` regardless.
+ */
+/**
+ * Bundle-mode counterpart to runDraftFlow's tail: given a successful Apollo
+ * provisioning result, auto-import the (already-active) version locally and
+ * drop the user into the project. No-op when provisioning failed (`null`).
+ * Templates never call this — they aren't runtime agents.
+ */
+async function autoImportAndEnter(created, dir, agentName) {
+    if (!created)
+        return;
+    const importedDir = await autoImportLatestDraft(created.agentId, {
+        versionId: created.activeVersionId,
+        tag: created.activeVersionTag,
+        dir,
+        agentName,
+    });
+    if (importedDir)
+        enterProjectShell(importedDir);
+}
+/**
+ * Whether the post-create auto-import + drop-into-project conveniences should
+ * run. They only make sense in a real interactive terminal — non-interactive
+ * creation (agent-builder-bff sandbox, CI, piped/redirected output, `--json`)
+ * must behave exactly like a plain create: no local import, no subshell.
+ *
+ * Resolution order:
+ *   1. JSON mode             → never (production contract: no Ink on stdout).
+ *   2. AUI_AUTO_IMPORT=1 / =0 → explicit opt-in / opt-out (automation + tests).
+ *   3. otherwise             → only when BOTH stdin and stdout are TTYs.
+ */
+function isInteractiveSession() {
+    if (isJsonMode())
+        return false;
+    if (process.env.AUI_AUTO_IMPORT === "1")
+        return true;
+    if (process.env.AUI_AUTO_IMPORT === "0")
+        return false;
+    return Boolean(process.stdin.isTTY) && Boolean(process.stdout.isTTY);
+}
+function enterProjectShell(dir) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY)
+        return;
+    const isWindows = process.platform === "win32";
+    const shell = process.env.SHELL ||
+        (isWindows ? process.env.COMSPEC || "cmd.exe" : "/bin/bash");
+    logView(_jsx(Box, { paddingX: 1, marginTop: 1, children: _jsx(StatusLine, { kind: "success", label: "Start building your agent!" }) }));
+    try {
+        // `-i` requests an interactive shell on POSIX so rc files load and the
+        // user gets their normal prompt; cmd.exe needs no flag. stdio is
+        // inherited so the nested shell owns the terminal until it exits.
+        spawnSync(shell, isWindows ? [] : ["-i"], {
+            cwd: dir,
+            stdio: "inherit",
+        });
+    }
+    catch {
+        // best-effort — the project is already on disk at `dir`.
+    }
+}
+/**
+ * Auto-import the latest draft of a freshly created agent.
+ *
+ * Called right after `versionCreate` seeds the v1.0 draft so `aui agents
+ * --create` lands the user in a ready-to-edit local project without a
+ * separate `aui import-agent` invocation.
+ *
+ *   - `dir` provided   → import into that exact directory.
+ *   - `dir` omitted    → import into a NEW `./<agent-name>` folder (a single
+ *                        self-contained project named after the agent), so
+ *                        the files are never dumped loose into the cwd.
+ *
+ * Best-effort: a failed import never fails the create (the agent + draft
+ * already exist server-side). We surface a hint to re-run `aui import-agent`
+ * manually instead.
+ *
+ * INTERACTIVE-ONLY: skipped entirely for non-interactive creation (see
+ * `isInteractiveSession`). The non-interactive `aui agents --create …`
+ * commands — agent-builder-bff in its E2B sandbox, CI, piped output, and any
+ * `--json` run — must behave exactly like a plain "create" (no local import,
+ * no subshell), so this returns `null` and the create just reports the new
+ * agent. Real terminals (or an explicit `AUI_AUTO_IMPORT=1`) get the import.
+ */
+async function autoImportLatestDraft(agentId, opts) {
+    if (!isInteractiveSession())
+        return null;
+    const targetDir = opts.dir || agentFolderName(opts.agentName);
+    // Resolve to an absolute path NOW, against the current cwd, before the
+    // import (which doesn't change cwd) — so the subshell gets an unambiguous
+    // directory and we never re-resolve a relative path twice.
+    const resolvedDir = path.resolve(targetDir);
+    try {
+        const { importAgent } = await import("./import-agent.js");
+        await importAgent(agentId, {
+            dir: targetDir,
+            version: opts.versionId,
+            tag: opts.versionId ? undefined : opts.tag,
+        });
+        return resolvedDir;
+    }
+    catch (error) {
+        logView(_jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [_jsx(StatusLine, { kind: "warning", label: `Auto-import failed: ${error instanceof Error ? error.message : String(error)}` }), _jsx(Text, { color: "gray", children: `  Import it manually with:  aui import-agent --dir ${targetDir}` })] }));
+        return null;
+    }
+}
+/**
+ * Build the default auto-import folder name from the agent's chosen name:
+ * a single `./<sanitized-name>` directory under the current working dir.
+ * Mirrors the sanitization `import-agent` uses for its own default folder
+ * so a created-then-imported agent and a manually imported one land in
+ * predictable, matching directory names. Falls back to `./agent` when the
+ * name is missing or sanitizes to empty.
+ */
+function agentFolderName(agentName) {
+    const safe = (agentName || "")
+        .toLowerCase()
+        .replace(/[\/\\:*?"<>|]/g, "-")
+        .replace(/\s+/g, "-")
+        .replace(/-+/g, "-")
+        .replace(/^-|-$/g, "");
+    return `./${safe || "agent"}`;
+}
+async function runFullFlow(agentId, bundleMode = false, dir, agentName) {
     // See runDraftFlow: blob-mode agents can't snapshot from agent-scope.
     if (bundleMode) {
         logView(_jsxs(Box, { flexDirection: "column", paddingX: 1, marginTop: 1, children: [_jsx(StatusLine, { kind: "info", label: "Bundle-mode agent created \u2014 skipping auto version flow (blob-mode has nothing to snapshot yet)." }), _jsx(Text, { color: "gray", children: "  Seed it from a template:  aui version create --source template --from-template <templateAgentId>" })] }));
@@ -1468,6 +1649,15 @@ async function runFullFlow(agentId, bundleMode = false) {
     await versionPublish(draft.id, agentId);
     // Activate
     await versionActivate(draft.id, agentId);
+    // Auto-import the (now-active) v1.0 locally, mirroring runDraftFlow.
+    const importedDir = await autoImportLatestDraft(agentId, {
+        versionId: draft.id,
+        dir,
+        agentName,
+    });
+    // Drop the user into the new project so they can start working right away.
+    if (importedDir)
+        enterProjectShell(importedDir);
 }
 function logView(node) {
     const inst = render(node);
@@ -1544,11 +1734,13 @@ async function createBundledAgentViaApollo(input) {
             delete session.version_revision_number;
             saveSession(session);
         }
-        const activeVersion = (typeof res.active_version_tag === "string" && res.active_version_tag) ||
-            (typeof res.active_version_id === "string" && res.active_version_id) ||
-            "";
-        logView(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "success", label: `${isTemplate ? "Template" : "Bundle agent"} created: ${res.name || input.name}${agentId ? ` (${agentId})` : ""}` }), isTemplate ? (_jsx(Text, { color: "gray", children: `  Use it as a clone source:  aui version create --source template --from-template ${agentId || "<templateId>"}` })) : (_jsx(Text, { color: "gray", children: "  Apollo provisioned it end-to-end: network → agent → version (from template) → published → activated." })), activeVersion ? (_jsx(StatusLine, { kind: "muted", label: `Active version: ${activeVersion}` })) : null, !isTemplate && agentId ? (_jsx(StatusLine, { kind: "muted", label: "Session updated to this agent." })) : null, !isTemplate ? (_jsxs(_Fragment, { children: [_jsx(Text, { children: " " }), _jsxs(Box, { children: [_jsx(Text, { color: "gray", children: "  Next: " }), _jsx(Text, { bold: true, children: "aui import-agent" }), _jsx(Text, { color: "gray", children: "  to download it locally." })] })] })) : null] }));
-        return agentId ? { agentId } : null;
+        const activeVersionId = typeof res.active_version_id === "string" ? res.active_version_id : undefined;
+        const activeVersionTag = typeof res.active_version_tag === "string" ? res.active_version_tag : undefined;
+        const activeVersion = activeVersionTag || activeVersionId || "";
+        logView(_jsxs(Box, { flexDirection: "column", paddingX: 1, children: [_jsx(StatusLine, { kind: "success", label: `${isTemplate ? "Template" : "Bundle agent"} created: ${res.name || input.name}${agentId ? ` (${agentId})` : ""}` }), isTemplate ? (_jsx(Text, { color: "gray", children: `  Use it as a clone source:  aui version create --source template --from-template ${agentId || "<templateId>"}` })) : (_jsx(Text, { color: "gray", children: "  Apollo provisioned it end-to-end: network → agent → version (from template) → published → activated." })), activeVersion ? (_jsx(StatusLine, { kind: "muted", label: `Active version: ${activeVersion}` })) : null, !isTemplate && agentId ? (_jsx(StatusLine, { kind: "muted", label: "Session updated to this agent." })) : null] }));
+        return agentId
+            ? { agentId, activeVersionId, activeVersionTag }
+            : null;
     }
     catch (error) {
         spinner.unmount();