@pikku/cli 0.12.128 → 0.12.134

package/dist/src/deploy/analyzer/analyzer.js

@@ -127,15 +127,17 @@ export function analyzeDeployment(state, options) {
         if (handlers.length === 0) {
             continue;
         }
+        const invokedAgents = collectInvokedAgents(state, funcId);
         units.push({
             name: toSafeKebab(funcId),
             role: 'function',
             target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
             functionIds: [funcId],
-            services: collectServicesForFunction(funcMeta),
+            services: withAgentServices(collectServicesForFunction(funcMeta), invokedAgents),
             dependsOn: [],
             handlers,
             tags: funcMeta.tags ?? [],
+            ...(invokedAgents.length > 0 && { invokedAgents }),
         });
     }
     // ── Step 2: Agent gateways ─────────────────────────────────────────
@@ -147,10 +149,7 @@ export function analyzeDeployment(state, options) {
         const toolUnitNames = toolIds.map((id) => toSafeKebab(id));
         const subAgentUnitNames = subAgentNames.map((sa) => `agent-${toSafeKebab(sa)}`);
         // Agent needs AI services
-        const agentServices = [
-            { capability: 'ai-model', sourceServiceName: 'agentRunner' },
-            { capability: 'ai-storage', sourceServiceName: 'agentStorage' },
-        ];
+        const agentServices = agentServiceRequirements();
         // Concrete routes for this agent via catch-all
         const agentRoutes = [
             {
@@ -282,15 +281,17 @@ export function analyzeDeployment(state, options) {
                 const funcId = fromKebab(dep);
                 const funcMeta = functionsMeta[funcId];
                 if (funcMeta) {
+                    const invokedAgents = collectInvokedAgents(state, funcId);
                     units.push({
                         name: dep,
                         role: 'function',
                         target: resolveDeployTarget(funcMeta, serverlessIncompatible, funcId, defaultTarget),
                         functionIds: [funcId],
-                        services: collectServicesForFunction(funcMeta),
+                        services: withAgentServices(collectServicesForFunction(funcMeta), invokedAgents),
                         dependsOn: [],
                         handlers: [{ type: 'fetch', routes: [] }],
                         tags: funcMeta.tags ?? [],
+                        ...(invokedAgents.length > 0 && { invokedAgents }),
                     });
                     existingUnitNames.add(dep);
                 }
@@ -597,6 +598,41 @@ function mapServiceToRequirement(serviceName) {
         return null;
     return { capability, sourceServiceName: serviceName };
 }
+function agentServiceRequirements() {
+    return [
+        { capability: 'ai-model', sourceServiceName: 'agentRunner' },
+        { capability: 'ai-storage', sourceServiceName: 'agentStorage' },
+    ];
+}
+/**
+ * Agents named by a `runAgent`/`rpc.agent.run` call inside a function body.
+ *
+ * The inspector attributes those calls to the source FILE, so every function
+ * declared alongside the caller inherits them. That is deliberate: the unit
+ * bundles the file either way, and registering an agent the caller never
+ * reaches is cheaper than the run-time "AI agent not found" a missed one
+ * causes.
+ */
+function collectInvokedAgents(state, funcId) {
+    const path = state.functions?.files?.get(funcId)?.path;
+    if (!path)
+        return [];
+    const invoked = state.agents?.invokedAgentsByFile?.get(path);
+    if (!invoked)
+        return [];
+    return [...invoked].filter((name) => Boolean(state.agents?.agentsMeta[name]));
+}
+function withAgentServices(services, invokedAgents) {
+    if (invokedAgents.length === 0)
+        return services;
+    const merged = [...services];
+    for (const requirement of agentServiceRequirements()) {
+        if (!merged.some((s) => s.capability === requirement.capability)) {
+            merged.push(requirement);
+        }
+    }
+    return merged;
+}
 function collectServicesForFunction(funcMeta) {
     if (!funcMeta?.services?.services)
         return [];

package/dist/src/deploy/build-pipeline.js

@@ -4,9 +4,9 @@
  * Runs: analyze → per-unit codegen → entry generation → bundle → configs
  * Outputs everything to .deploy/<provider>/ without deploying.
  */
-import { join } from 'node:path';
-import { existsSync } from 'node:fs';
-import { mkdir, writeFile, copyFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { existsSync, readFileSync } from 'node:fs';
+import { cp, mkdir, writeFile, copyFile } from 'node:fs/promises';
 import { PikkuError } from '@pikku/core/errors';
 import { analyzeDeployment } from './analyzer/index.js';
 import { withoutScenarios } from '../functions/wirings/scenarios/scenario-partition.js';
@@ -61,6 +61,88 @@ function findLockfile(projectDir) {
     }
     return null;
 }
+/**
+ * The database a standalone bundle has to open for itself.
+ *
+ * Every other provider deploys onto a host that supplies `kysely` — `pikku dev`
+ * builds one, a Cloudflare deploy binds one — so `createSingletonServices` is
+ * written expecting it. A standalone artifact has no host, and shipped one that
+ * never got a connection at all: the app booted straight into whatever its
+ * services factory does when the database is missing, which for the generated
+ * templates is a throw.
+ *
+ * Engine comes from the migrations directory rather than the user config,
+ * because that is the same signal `loadUserConfigForDb` falls back to and it
+ * needs no module loading here. `db/sqlite` and `db/postgres` are the two
+ * conventions the migrator already writes to, so a project declares its engine
+ * by having written migrations for it.
+ *
+ * Both at once is refused rather than resolved. Picking one would be picking
+ * which database the deployed app talks to on the strength of directory order,
+ * and the failure — an app running happily against the wrong, fully valid
+ * schema — is invisible until someone reads the data.
+ *
+ * The migrations are copied in beside the bundle under the same `db/<engine>/`
+ * path they have in the project, which is also where Fabric's build container
+ * stages them. Two producers writing the artifact cannot disagree about where
+ * the SQL lives, and `bundle.js db migrate` finds it either way.
+ */
+/**
+ * The project's declared version, or nothing.
+ *
+ * Absent is a real answer — a project need not version itself — and is better
+ * reported as unknown than as a number this made up.
+ */
+function resolveProjectVersion(projectDir) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(projectDir, 'package.json'), 'utf-8'));
+        return typeof pkg.version === 'string' ? pkg.version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function resolveStandaloneDb(projectDir, pikkuDir, unitDir) {
+    const hasSqlite = existsSync(join(projectDir, 'db', 'sqlite'));
+    const hasPostgres = existsSync(join(projectDir, 'db', 'postgres'));
+    if (hasSqlite && hasPostgres) {
+        throw new Error('This project has both db/sqlite and db/postgres migrations, so a standalone build cannot tell which database the app is meant to open. Keep the one this app deploys against.');
+    }
+    const engine = hasSqlite ? 'sqlite' : hasPostgres ? 'postgres' : undefined;
+    if (!engine)
+        return undefined;
+    await cp(join(projectDir, 'db', engine), join(unitDir, 'db', engine), {
+        recursive: true,
+    });
+    // Absent for an app that annotates no columns, which is a database with
+    // nothing to coerce rather than a reason to hand the app no database.
+    const coercionFile = join(pikkuDir, 'db', 'coercion.gen.ts');
+    if (!existsSync(coercionFile))
+        return { engine };
+    let rel = relative(unitDir, coercionFile).replace(/\\/g, '/');
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    return { engine, coercionImportPath: rel.replace(/\.ts$/, '.js') };
+}
+/**
+ * The app's server lifecycle, for entries that can call it.
+ *
+ * The hooks are resolved to an import rather than read at build time because
+ * they are the app's own code and have to run in the app's own process, with
+ * the services that process built.
+ */
+function resolveLifecycle(unitDir, state) {
+    const factory = state.filesAndMethods.serverLifecycleFactory;
+    if (!factory)
+        return undefined;
+    let rel = relative(unitDir, factory.file).replace(/\\/g, '/');
+    if (!rel.startsWith('.'))
+        rel = `./${rel}`;
+    return {
+        importPath: rel.replace(/\.tsx?$/, '.js'),
+        variable: factory.variable,
+    };
+}
 export async function runBuildPipeline(options) {
     const { projectDir, projectId, provider, inspectorState, getEntryContext, debugArtifacts, logger, bundler, } = options;
     const deployDir = options.deployDir ?? join(projectDir, '.deploy');
@@ -115,6 +197,9 @@ export async function runBuildPipeline(options) {
         const ctx = {
             ...getEntryContext(unitDir, pikkuDir, singleUnit, inspectorState),
             frontend: frontendMount,
+            version: resolveProjectVersion(projectDir),
+            db: await resolveStandaloneDb(projectDir, pikkuDir, unitDir),
+            lifecycle: resolveLifecycle(unitDir, inspectorState),
         };
         const source = provider.generateEntrySource(ctx);
         const entryPath = join(unitDir, 'entry.ts');
@@ -228,7 +313,10 @@ export async function runBuildPipeline(options) {
             const unitDir = unit.target === 'server' ? containerDir : join(unitsDir, unit.name);
             const entryPath = join(unitDir, 'entry.ts');
             await mkdir(unitDir, { recursive: true });
-            const ctx = getEntryContext(unitDir, pikkuDir, unit, inspectorState);
+            const ctx = {
+                ...getEntryContext(unitDir, pikkuDir, unit, inspectorState),
+                lifecycle: resolveLifecycle(unitDir, inspectorState),
+            };
             const source = unit.target === 'server'
                 ? (provider.generateServerEntrySource?.(ctx) ??
                     generateServerEntrySource(ctx))

package/dist/src/deploy/codegen/per-unit-codegen.d.ts

@@ -42,6 +42,16 @@ export interface PerUnitCodegenResult {
         error: string;
     }>;
 }
+/**
+ * Collect the full set of filter names for a deployment unit.
+ *
+ * The --names filter matches against different identifier types depending
+ * on the metadata being filtered (function names, agent names, channel
+ * names, etc.).  For a unit to get its complete metadata, we need to
+ * include both the function IDs and any wiring-level names (e.g. agent
+ * names, channel names) that reference those functions.
+ */
+export declare function collectFilterNames(unit: DeploymentUnit, manifest: DeploymentManifest, inspectorState: InspectorState, workflowQueues: boolean): string[];
 /**
  * Runs filtered codegen for each deployment unit.
  *

package/dist/src/deploy/codegen/per-unit-codegen.js

@@ -34,7 +34,7 @@ function resolvePikkuBin() {
  * include both the function IDs and any wiring-level names (e.g. agent
  * names, channel names) that reference those functions.
  */
-function collectFilterNames(unit, manifest, inspectorState, workflowQueues) {
+export function collectFilterNames(unit, manifest, inspectorState, workflowQueues) {
     const names = new Set(unit.functionIds);
     // Include catch-all scaffold routes based on unit contents
     const functionsMeta = inspectorState.functions.meta;
@@ -103,6 +103,17 @@ function collectFilterNames(unit, manifest, inspectorState, workflowQueues) {
                 if (handler.type === 'scheduled')
                     names.add(handler.taskName);
             }
+            // `runAgent(...)` / `rpc.agent.run(...)` look the agent up in the
+            // in-process registry, so a function that calls one needs the agent's
+            // wiring — and its tools — bundled into its OWN unit, not just into
+            // the agent gateway unit.
+            for (const agentName of unit.invokedAgents ?? []) {
+                names.add(agentName);
+                const agentDef = manifest.agents.find((a) => a.name === agentName);
+                for (const id of agentDef?.toolFunctionIds ?? [])
+                    names.add(id);
+                names.add('/rpc/:rpcName');
+            }
             // Function units with workflow-state capability (workflow-starter,
             // workflow-runner, workflow-status-checker) call rpc.startWorkflow
             // and look workflows up by name in the registry. The registry is

package/dist/src/deploy/server-entry.js

@@ -18,6 +18,11 @@ export function generateServerEntrySource(ctx) {
         ctx.configImport,
         ctx.servicesImport,
         ctx.mcpImport,
+        ...(ctx.lifecycle
+            ? [
+                `import { ${ctx.lifecycle.variable} as __pikkuLifecycle } from '${ctx.lifecycle.importPath}'`,
+            ]
+            : []),
         `import '${ctx.bootstrapPath}'`,
         ``,
         `const PORT = Number(process.env.PORT ?? 8080)`,
@@ -33,9 +38,17 @@ export function generateServerEntrySource(ctx) {
         `    singletonServices.logger,`,
         `    { ${ctx.mcpServerOption}}`,
         `  )`,
-        `  server.enableExitOnSignals()`,
+        `  server.enableExitOnSignals(${ctx.lifecycle
+            ? `{ beforeStop: () => __pikkuLifecycle?.beforeStop?.(singletonServices), afterStop: () => __pikkuLifecycle?.afterStop?.(singletonServices) }`
+            : ''})`,
         `  await server.init()`,
+        ...(ctx.lifecycle
+            ? [`  await __pikkuLifecycle?.beforeStart?.(singletonServices)`]
+            : []),
         `  await server.start()`,
+        ...(ctx.lifecycle
+            ? [`  await __pikkuLifecycle?.afterStart?.(singletonServices)`]
+            : []),
         `}`,
         ``,
         `main().catch((err) => {`,

package/dist/src/fabric/fabric-commands.d.ts

@@ -284,7 +284,7 @@ export declare const fabricCommands: {
                 production?: boolean | undefined;
                 ref?: string | undefined;
                 deploymentId?: string | undefined;
-                sync?: boolean | undefined;
+                detach?: boolean | undefined;
                 autoApprove?: boolean | undefined;
                 allowDestructive?: boolean | undefined;
                 timeout?: number | undefined;
@@ -347,7 +347,7 @@ export declare const fabricCommands: {
                 production?: boolean | undefined;
                 ref?: string | undefined;
                 deploymentId?: string | undefined;
-                sync?: boolean | undefined;
+                detach?: boolean | undefined;
                 autoApprove?: boolean | undefined;
                 allowDestructive?: boolean | undefined;
                 timeout?: number | undefined;
@@ -410,7 +410,7 @@ export declare const fabricCommands: {
                 production?: boolean | undefined;
                 ref?: string | undefined;
                 deploymentId?: string | undefined;
-                sync?: boolean | undefined;
+                detach?: boolean | undefined;
                 autoApprove?: boolean | undefined;
                 allowDestructive?: boolean | undefined;
                 timeout?: number | undefined;

package/dist/src/fabric/fabric-commands.js

@@ -160,11 +160,11 @@ export const fabricCommands = defineCLICommands({
         description: 'Apply and inspect deploys for a named branch or production',
         subcommands: {
             apply: pikkuCLICommand({
+                parameters: '[branch]',
                 func: FabricDeployApply,
                 render: renderDeployApply,
                 description: 'Build + deploy a named branch or production (main), or attach to an existing deployment',
                 options: {
-                    branch: { description: 'Target branch to deploy', short: 'b' },
                     production: {
                         description: 'Deploy production (always main)',
                         default: false,
@@ -173,22 +173,23 @@ export const fabricCommands = defineCLICommands({
                         description: 'Deploy a specific ref instead of the branch head',
                     },
                     deploymentId: {
-                        description: 'Attach to an existing deployment instead of creating one (not with --branch/--production)',
+                        description: 'Attach to an existing deployment instead of creating one (not with a branch/--production)',
                     },
-                    sync: {
-                        description: 'Wait for the deployment to finish and exit non-zero unless it went live',
+                    detach: {
+                        description: 'Queue the deployment and exit without waiting, reporting nothing about whether it landed',
                         default: false,
                     },
                     autoApprove: {
                         description: 'Answer the confirmation prompt and publish a plan parked at the approval gate',
+                        short: 'y',
                         default: false,
                     },
                     allowDestructive: {
-                        description: 'Approve a plan whose migrations drop or rewrite data (--auto-approve alone will not)',
+                        description: 'Approve a plan whose migrations drop or rewrite data (-y alone will not)',
                         default: false,
                     },
                     timeout: {
-                        description: 'Seconds to wait under --sync (default 900)',
+                        description: 'Seconds to wait for the deployment (default 900)',
                     },
                     json: {
                         description: 'Machine-readable output (NDJSON)',

package/dist/src/fabric/functions/deploy.function.d.ts

@@ -4,7 +4,7 @@ export declare const FabricDeployInput: z.ZodObject<{
     production: z.ZodOptional<z.ZodBoolean>;
     ref: z.ZodOptional<z.ZodString>;
     deploymentId: z.ZodOptional<z.ZodString>;
-    sync: z.ZodOptional<z.ZodBoolean>;
+    detach: z.ZodOptional<z.ZodBoolean>;
     autoApprove: z.ZodOptional<z.ZodBoolean>;
     allowDestructive: z.ZodOptional<z.ZodBoolean>;
     timeout: z.ZodOptional<z.ZodNumber>;
@@ -15,7 +15,7 @@ export declare const FabricDeployValidatedInput: z.ZodObject<{
     production: z.ZodOptional<z.ZodBoolean>;
     ref: z.ZodOptional<z.ZodString>;
     deploymentId: z.ZodOptional<z.ZodString>;
-    sync: z.ZodOptional<z.ZodBoolean>;
+    detach: z.ZodOptional<z.ZodBoolean>;
     autoApprove: z.ZodOptional<z.ZodBoolean>;
     allowDestructive: z.ZodOptional<z.ZodBoolean>;
     timeout: z.ZodOptional<z.ZodNumber>;
@@ -90,12 +90,21 @@ export declare const FabricDeployApplyOutput: z.ZodObject<{
     timeoutSeconds: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type ApplyOutput = z.infer<typeof FabricDeployApplyOutput>;
+/**
+ * The branch to deploy when none was named, read off the checkout.
+ *
+ * `git rev-parse --abbrev-ref HEAD` answers the literal string `HEAD` on a
+ * detached checkout, which is not a branch and would be reported downstream as
+ * a branch that does not exist locally. Naming the real problem here is the
+ * difference between "check out a branch" and a puzzle.
+ */
+export declare const branchFromHead: (head: string) => string;
 export declare const FabricDeployApply: import("../../../.pikku/function/pikku-function-types.gen.js").PikkuFunctionConfig<{
     branch?: string | undefined;
     production?: boolean | undefined;
     ref?: string | undefined;
     deploymentId?: string | undefined;
-    sync?: boolean | undefined;
+    detach?: boolean | undefined;
     autoApprove?: boolean | undefined;
     allowDestructive?: boolean | undefined;
     timeout?: number | undefined;
@@ -158,7 +167,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     production?: boolean | undefined;
     ref?: string | undefined;
     deploymentId?: string | undefined;
-    sync?: boolean | undefined;
+    detach?: boolean | undefined;
     autoApprove?: boolean | undefined;
     allowDestructive?: boolean | undefined;
     timeout?: number | undefined;
@@ -221,7 +230,7 @@ export declare const FabricDeployApply: import("../../../.pikku/function/pikku-f
     production?: boolean | undefined;
     ref?: string | undefined;
     deploymentId?: string | undefined;
-    sync?: boolean | undefined;
+    detach?: boolean | undefined;
     autoApprove?: boolean | undefined;
     allowDestructive?: boolean | undefined;
     timeout?: number | undefined;

package/dist/src/fabric/functions/deploy.function.js

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { pikkuSessionlessFunc } from '../../../.pikku/function/index.js';
 import { resolveApiContext } from '../lib/config.js';
 import { getFabricRPC } from '../lib/http.js';
-import { assertNamedBranchDeploySafety, resolveRef } from '../lib/git.js';
+import { assertNamedBranchDeploySafety, currentBranch, resolveRef, } from '../lib/git.js';
 import { promptConfirm } from '../lib/prompt.js';
 import { added, changed, removed, dim, table } from '../lib/output.js';
 import { blockedReason, blockedSummary, missingConfigHints, changesAreEmpty, classifyStatus, describeDeployment, destructiveMigrations, isApprovable, readDeploymentStatus, readWorkers, reconcileDeployedRef, stateLabel, waitForDeployment, } from '../lib/deployment.js';
@@ -12,7 +12,7 @@ export const FabricDeployInput = z.object({
     production: z.boolean().optional(),
     ref: z.string().optional(),
     deploymentId: z.string().optional(),
-    sync: z.boolean().optional(),
+    detach: z.boolean().optional(),
     autoApprove: z.boolean().optional(),
     allowDestructive: z.boolean().optional(),
     timeout: z.number().optional(),
@@ -23,15 +23,15 @@ export const FabricDeployValidatedInput = FabricDeployInput.superRefine((value,
         if (value.branch || value.production) {
             ctx.addIssue({
                 code: z.ZodIssueCode.custom,
-                message: '--deployment-id already names its target — drop --branch/--production.',
+                message: '--deployment-id already names its target — drop the branch/--production.',
             });
         }
         return;
     }
-    if (!!value.branch === !!value.production) {
+    if (value.branch && value.production) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
-            message: 'Pass exactly one of --branch or --production.',
+            message: 'Pass a branch or --production, not both — --production is always main.',
         });
     }
 });
@@ -96,16 +96,25 @@ async function prepDeploy({ branch, production, ref }) {
     if (!ctx.projectId) {
         throw new Error('No fabric project linked. Run `pikku fabric link` first.');
     }
-    // Guarded rather than asserted: the schema-level refine is bypassed whenever
-    // the function is called outside CLI arg parsing, and `branch!` turned that
-    // into "local branch undefined does not exist" — an error that names nothing.
-    if (!production && !branch) {
-        throw new Error('Pass exactly one of --branch or --production.');
-    }
-    const targetBranch = production ? 'main' : branch;
+    // With no target named, deploy the branch that is checked out — the common
+    // case, and the one worth not making people type twice. It is only safe to
+    // infer because `assertNamedBranchDeploySafety` below refuses any branch that
+    // is missing an upstream or out of sync with it, so an inferred target cannot
+    // ship something that was never pushed.
+    const inferred = !production && !branch;
+    const targetBranch = production
+        ? 'main'
+        : (branch ?? branchFromHead(await currentBranch()));
     const safety = await assertNamedBranchDeploySafety(targetBranch);
     const resolved = ref ? ((await resolveRef(ref)) ?? ref) : safety.headSha;
-    return { ctx, projectId: ctx.projectId, targetBranch, resolved, safety };
+    return {
+        ctx,
+        projectId: ctx.projectId,
+        targetBranch,
+        resolved,
+        safety,
+        inferred,
+    };
 }
 async function prepAttach() {
     const ctx = await resolveApiContext();
@@ -124,6 +133,20 @@ const EXIT_BY_OUTCOME = {
     blocked: 3,
     timeout: 4,
 };
+/**
+ * The branch to deploy when none was named, read off the checkout.
+ *
+ * `git rev-parse --abbrev-ref HEAD` answers the literal string `HEAD` on a
+ * detached checkout, which is not a branch and would be reported downstream as
+ * a branch that does not exist locally. Naming the real problem here is the
+ * difference between "check out a branch" and a puzzle.
+ */
+export const branchFromHead = (head) => {
+    if (head === 'HEAD' || head === '') {
+        throw new Error('Deployment blocked: HEAD is detached, so there is no current branch to deploy.\nCheck out a branch, or name the target: `pikku fabric deploy apply <branch>`.');
+    }
+    return head;
+};
 export const FabricDeployApply = pikkuSessionlessFunc({
     description: 'Build + deploy a named branch or production (main), or attach to an existing deployment.',
     input: FabricDeployValidatedInput,
@@ -137,7 +160,7 @@ export const FabricDeployApply = pikkuSessionlessFunc({
             throw new Error('--timeout must be a positive number of seconds.');
         }
         if (input.deploymentId && (input.branch || input.production)) {
-            throw new Error('--deployment-id already names its target — drop --branch/--production.');
+            throw new Error('--deployment-id already names its target — drop the branch/--production.');
         }
         const attaching = Boolean(input.deploymentId);
         let projectId;
@@ -158,11 +181,17 @@ export const FabricDeployApply = pikkuSessionlessFunc({
             emit({ event: 'attached', deploymentId, status: current.status });
         }
         else {
-            const { ctx, projectId: id, targetBranch, resolved, safety, } = await prepDeploy(input);
+            const { ctx, projectId: id, targetBranch, resolved, safety, inferred, } = await prepDeploy(input);
             projectId = id;
             branch = targetBranch;
             ref = resolved;
             rpc = getFabricRPC({ apiUrl: ctx.apiUrl, token: ctx.token });
+            // An inferred target is said out loud before anything is built. Under -y
+            // there is no confirmation prompt to name it, and a deploy that never
+            // told you which branch it picked is the one that ships the wrong branch.
+            if (inferred && !input.json) {
+                console.log(dim(`Deploying the current branch: ${targetBranch}`));
+            }
             if (!input.autoApprove) {
                 const target = `${branch} @ ${resolved.slice(0, 8)}`;
                 if (!process.stdin.isTTY) {
@@ -202,7 +231,7 @@ export const FabricDeployApply = pikkuSessionlessFunc({
             ...(stageId ? { stageId } : {}),
             ...(runId ? { runId } : {}),
         };
-        if (!input.sync && !attaching) {
+        if (input.detach && !attaching) {
             return { ...base, outcome: 'queued' };
         }
         let approvalWithheld;
@@ -225,7 +254,7 @@ export const FabricDeployApply = pikkuSessionlessFunc({
                 : '';
             return promptConfirm(`Plan for ${branch ?? deploymentId} is ready to publish (${stateLabel(status.status, status.statusReason)}).${warning} Approve?`);
         };
-        if (!input.sync) {
+        if (input.detach) {
             const status = await readDeploymentStatus(rpc, deploymentId);
             const klass = classifyStatus(status.status);
             const outcome = klass === 'in_flight' ? 'queued' : klass;
@@ -324,7 +353,7 @@ const missingLines = (label, entries) => {
         ...entries.map((e) => `    ${e.name}${e.displayName ? dim(` (${e.displayName})`) : ''}${e.docsUrl ? dim(` — ${e.docsUrl}`) : ''}`),
     ];
 };
-const reattachHint = (deploymentId) => dim(`Re-attach with \`pikku fabric deploy apply --deployment-id ${deploymentId} --sync\`.`);
+const reattachHint = (deploymentId) => dim(`Re-attach with \`pikku fabric deploy apply --deployment-id ${deploymentId}\`.`);
 export const renderDeployApply = (_s, result) => {
     const { outcome, branch, ref, deploymentId, status, statusReason, changes, workers, url, elapsedMs, timeoutSeconds, approved, } = result;
     const where = branch ?? 'deployment';
@@ -363,10 +392,10 @@ export const renderDeployApply = (_s, result) => {
             console.log(line);
         if (result.approvalWithheld === 'destructive_migrations') {
             console.log(dim('The plan drops or rewrites data. Nothing was published — review the migrations above, then re-run with `--allow-destructive` to accept them.'));
-            console.log(dim(`\`pikku fabric deploy apply --deployment-id ${deploymentId} --sync --auto-approve --allow-destructive\``));
+            console.log(dim(`\`pikku fabric deploy apply --deployment-id ${deploymentId} -y --allow-destructive\``));
         }
         else if (isApprovable(reason) && !approved) {
-            console.log(dim(`Approve it with \`pikku fabric deploy apply --deployment-id ${deploymentId} --sync --auto-approve\`.`));
+            console.log(dim(`Approve it with \`pikku fabric deploy apply --deployment-id ${deploymentId} -y\`.`));
         }
         else if (reason === 'needs_config') {
             for (const hint of missingConfigHints(result.missingSecrets, result.missingVariables)) {

package/dist/src/fabric/lib/stage.js

@@ -23,7 +23,7 @@ export async function resolveStage(rpc, projectId, branch) {
             return { stageId: only.stageId, branch: only.branch };
         }
         throw new Error(stages.length === 0
-            ? 'No stages deployed for this project yet — run `pikku fabric deploy apply --branch <branch>` first.'
+            ? 'No stages deployed for this project yet — run `pikku fabric deploy apply <branch>` first.'
             : `--branch is required — this project has ${stages.length} stages: ${known.join(', ')}`);
     }
     const stage = stages.find((s) => s.branch === branch);