@nanobpm/urban 0.96.2 → 0.96.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export * from "./runtime/index.ts";
 export { createCamundaClient } from "@nanobpm/nano-sdk";
 export * from "./toolkit/index.ts";
-export { defineFlow, declarativeToBpmn, declarativeToLayoutedBpmn, externalJobTypes, envelope, layoutBpmn, toBpmn, toDeployableBpmn, Worker, WorkflowClient, WorkflowError, } from "@nanobpm/workflow";
+export { defineFlow, declarativeToBpmn, declarativeToLayoutedBpmn, externalJobTypes, inlineJobTypes, envelope, layoutBpmn, toBpmn, toDeployableBpmn, Worker, WorkflowClient, WorkflowError, } from "@nanobpm/workflow";
 export type { FlowBuilder, TimerStart, Envelope, EnvelopeType, EnvelopeField, FieldSpec, ScalarType, WorkflowClientOptions, NanoSdkClient, NanoJobWorker, JobWorkerConfig, ActivatedJob, WorkerOptions, ActivityEvent, } from "@nanobpm/workflow";

package/dist/index.js

@@ -22,4 +22,4 @@ export { createCamundaClient } from "@nanobpm/nano-sdk";
 // Toolkit — derivation library (`urban gen`)
 export * from "./toolkit/index.js";
 // Code-first process surface (re-exported from @nanobpm/workflow)
-export { defineFlow, declarativeToBpmn, declarativeToLayoutedBpmn, externalJobTypes, envelope, layoutBpmn, toBpmn, toDeployableBpmn, Worker, WorkflowClient, WorkflowError, } from "@nanobpm/workflow";
+export { defineFlow, declarativeToBpmn, declarativeToLayoutedBpmn, externalJobTypes, inlineJobTypes, envelope, layoutBpmn, toBpmn, toDeployableBpmn, Worker, WorkflowClient, WorkflowError, } from "@nanobpm/workflow";

package/dist/toolkit/gen.d.ts

@@ -48,6 +48,16 @@ export interface GenResult {
     incomplete: boolean;
     /** Per-file model-derivation errors (empty on success). */
     modelErrors: ModelError[];
+    /** Job types of inline-handled (`w.run`) code-first steps — the set the app's in-process
+     *  Worker already serves (nano-ide#595). The worker-stub scaffolder skips these; empty for a
+     *  model-first app. */
+    inlineTaskTypes: string[];
+    /** The code-first models derived in-memory this run (`deriveModels().models`) — the
+     *  worker-stub scaffolder plans against these in addition to the on-disk models, since a
+     *  declared `models` block (e.g. `models.workflows`) suppresses the `resources/` convention
+     *  scan that would otherwise pick the written `.bpmn` up (nano-ide#595). Empty for a
+     *  model-first app. */
+    derivedModels: ModelSource[];
     /** Non-fatal spec-hygiene warnings (e.g. a requestBody schema shared by >1 operation). Empty on
      *  a clean spec. Surfaced by the CLI but never fail gen/check — advisory only. */
     warnings: string[];

package/dist/toolkit/gen.js

@@ -257,7 +257,7 @@ export async function runGen(opts) {
             swept.push(rel);
         }
     }
-    return { artifacts, drift, swept: swept.sort(), incomplete: derived.incomplete, modelErrors: derived.errors, warnings };
+    return { artifacts, drift, swept: swept.sort(), incomplete: derived.incomplete, modelErrors: derived.errors, inlineTaskTypes: derived.inlineTaskTypes, derivedModels: derived.models, warnings };
 }
 export { dirOf, join as joinPath };
 /** Derive code-first models in-memory (no writes) — backs `urban derive --stdout`, the

package/dist/toolkit/generate.js

@@ -30,7 +30,15 @@ export async function generate(opts) {
         return empty;
     const write = !opts.check;
     const scaffoldOpts = { root: opts.root, io: opts.io, manifestFile: opts.manifestFile, write };
-    const workers = await scaffoldWorkers(scaffoldOpts);
+    // Inline-handled (`w.run`) steps are already served by the app's in-process Worker — never
+    // scaffold a competing throwing stub for them (nano-ide#595). The derived models are also
+    // handed over: a code-first manifest's declared `models` block suppresses the resources/
+    // convention scan in readModels, so without them the scaffolder would plan from nothing.
+    const workers = await scaffoldWorkers({
+        ...scaffoldOpts,
+        inlineTaskTypes: res.inlineTaskTypes,
+        extraModels: res.derivedModels,
+    });
     const operations = await scaffoldOperations(scaffoldOpts);
     const missingStubs = [
         ...workers.outcomes.filter((o) => o.status === "would-create").map((o) => o.handlerPath),

package/dist/toolkit/models.d.ts

@@ -38,6 +38,13 @@ export interface DerivedModels {
     models: ModelSource[];
     /** Derived flow ids (used for the provenance-scoped stale sweep). */
     ids: string[];
+    /** Job types of inline-handled (`w.run`) steps across every derived declarative flow —
+     *  the set the app's in-process Worker already serves (nano-ide#595). The worker-stub
+     *  scaffolder skips these; only `w.task` (external) steps may be scaffolded. Empty when
+     *  derivation was a no-op (no loader / no workflow files) or all flows are imperative
+     *  (an imperative flow's steps run inside its single `:__orchestrate` job, which the
+     *  planner already skips). */
+    inlineTaskTypes: string[];
     /** Per-flow `{ id, kind, xml }` for the non-writing preview (`urban derive --stdout`). */
     list: DerivedModelInfo[];
     /** The output directory the artifacts were written into. */

package/dist/toolkit/models.js

@@ -8,7 +8,7 @@
 // optional `GenIO.importModule` (present on Node with type-stripping, and on Deno). When the
 // loader is absent — or the app authors its models directly (model-first) — derivation is a
 // no-op and the rest of `urban gen` proceeds on the authored/derived models unchanged.
-import { toDeployableBpmn } from "@nanobpm/workflow";
+import { inlineJobTypes, toDeployableBpmn } from "@nanobpm/workflow";
 import { expandPattern, joinPath } from "./gen.js";
 import { isRecord } from "../runtime/core/guards.js";
 /** Default source glob for code-first flows (matches the code-first scaffold layout). */
@@ -54,6 +54,7 @@ function emptyDerived(outDir) {
         artifacts: [],
         models: [],
         ids: [],
+        inlineTaskTypes: [],
         list: [],
         outDir,
         attempted: false,
@@ -131,6 +132,8 @@ export async function deriveModels(root, io, manifest) {
                 const path = `${outDir}/${bpmnFilename(id)}`;
                 out.artifacts.push({ path, content: xml });
                 out.models.push({ path, xml });
+                if (value.kind === "declarative")
+                    out.inlineTaskTypes.push(...inlineJobTypes(value));
                 out.list.push({ id, kind: value.kind, xml });
                 out.ids.push(id);
             }

package/dist/toolkit/scaffold/workers.d.ts

@@ -26,7 +26,7 @@ export interface WorkerStubPlan {
     stub: string;
     manifestEntry: StubManifestEntry;
 }
-export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external";
+export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external" | "inline";
 export interface SkippedWorker {
     taskType: string;
     reason: SkipReason;
@@ -42,9 +42,12 @@ export declare function renderWorkerStub(taskType: string, typedIn: boolean, typ
 /**
  * Plan write-once handler stubs from the models. A stub is planned for each service-task
  * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, NOT
- * declared external (serviced by an out-of-process worker), and not a duplicate of one already
- * planned. `declaredTypeIds` are the manifest `types` ids — an envelope `in`/`out` is typed only
- * when it names one (matching the worker-io deriver). `externalTaskTypes` are the manifest's
- * declared external task types, which the app owns the model for but deliberately does not host.
+ * declared external (serviced by an out-of-process worker), NOT inline-handled (a code-first
+ * `w.run` step whose handler the app's in-process Worker already serves — nano-ide#595), and
+ * not a duplicate of one already planned. `declaredTypeIds` are the manifest `types` ids — an
+ * envelope `in`/`out` is typed only when it names one (matching the worker-io deriver).
+ * `externalTaskTypes` are the manifest's declared external task types, which the app owns the
+ * model for but deliberately does not host. `inlineTaskTypes` are the flow-derived inline
+ * (`w.run`) job types (`deriveModels().inlineTaskTypes`).
  */
-export declare function planWorkerScaffold(models: ModelSource[], workers?: ScaffoldWorker[], declaredTypeIds?: Iterable<string>, externalTaskTypes?: Iterable<string>): WorkerScaffoldPlan;
+export declare function planWorkerScaffold(models: ModelSource[], workers?: ScaffoldWorker[], declaredTypeIds?: Iterable<string>, externalTaskTypes?: Iterable<string>, inlineTaskTypes?: Iterable<string>): WorkerScaffoldPlan;

package/dist/toolkit/scaffold/workers.js

@@ -65,17 +65,21 @@ export function renderWorkerStub(taskType, typedIn, typedOut) {
 /**
  * Plan write-once handler stubs from the models. A stub is planned for each service-task
  * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, NOT
- * declared external (serviced by an out-of-process worker), and not a duplicate of one already
- * planned. `declaredTypeIds` are the manifest `types` ids — an envelope `in`/`out` is typed only
- * when it names one (matching the worker-io deriver). `externalTaskTypes` are the manifest's
- * declared external task types, which the app owns the model for but deliberately does not host.
+ * declared external (serviced by an out-of-process worker), NOT inline-handled (a code-first
+ * `w.run` step whose handler the app's in-process Worker already serves — nano-ide#595), and
+ * not a duplicate of one already planned. `declaredTypeIds` are the manifest `types` ids — an
+ * envelope `in`/`out` is typed only when it names one (matching the worker-io deriver).
+ * `externalTaskTypes` are the manifest's declared external task types, which the app owns the
+ * model for but deliberately does not host. `inlineTaskTypes` are the flow-derived inline
+ * (`w.run`) job types (`deriveModels().inlineTaskTypes`).
  */
-export function planWorkerScaffold(models, workers = [], declaredTypeIds = [], externalTaskTypes = []) {
+export function planWorkerScaffold(models, workers = [], declaredTypeIds = [], externalTaskTypes = [], inlineTaskTypes = []) {
     const wired = new Set(workers
         .map((w) => w?.taskType)
         .filter((t) => typeof t === "string" && t.length > 0));
     const declared = new Set(declaredTypeIds);
     const external = new Set(externalTaskTypes);
+    const inline = new Set(inlineTaskTypes);
     const plans = [];
     const skipped = [];
     const seenTaskTypes = new Set();
@@ -91,6 +95,10 @@ export function planWorkerScaffold(models, workers = [], declaredTypeIds = [], e
                 skipped.push({ taskType, reason: "external" });
                 continue;
             }
+            if (inline.has(taskType)) {
+                skipped.push({ taskType, reason: "inline" });
+                continue;
+            }
             if (wired.has(taskType)) {
                 skipped.push({ taskType, reason: "already-wired" });
                 continue;

package/dist/toolkit/scaffold.d.ts

@@ -1,4 +1,5 @@
 import type { GenIO } from "./gen.ts";
+import type { ModelSource } from "./derivers/worker-io.ts";
 import { type SkippedWorker, type StubManifestEntry } from "./scaffold/workers.ts";
 /**
  * Detect the indentation of a JSON document from its first indented line, so a rewrite can
@@ -18,6 +19,22 @@ export interface ScaffoldOptions {
     manifestFile?: string;
     /** Apply changes (create files + patch manifest). Default false = dry-run. */
     write?: boolean;
+    /**
+     * Job types of inline-handled (`w.run`) code-first steps — the set the app's in-process
+     * Worker already serves (nano-ide#595). The planner skips these with reason `"inline"` so
+     * `urban gen` never scaffolds a throwing stub that competes with the real handler. Pass
+     * `deriveModels().inlineTaskTypes` (the `generate` composition does).
+     */
+    inlineTaskTypes?: Iterable<string>;
+    /**
+     * Extra in-memory models to plan against in addition to the on-disk ones `readModels`
+     * resolves (nano-ide#595). A code-first app's derived `.bpmn` lives under
+     * `resources/processes/`, which `readModels` does NOT resolve when the manifest declares a
+     * `models` block (e.g. `models.workflows`) without `models.processes` — a declared block
+     * suppresses the `resources/` convention. Pass `deriveModels().models` so the scaffolder
+     * plans from the same fused model set the type-contract derivers saw.
+     */
+    extraModels?: ModelSource[];
 }
 export type StubStatus = "created" | "would-create" | "kept";
 export interface StubOutcome {

package/dist/toolkit/scaffold.js

@@ -38,9 +38,16 @@ export async function scaffoldWorkers(opts) {
     // Preserve the manifest's own indentation when we patch it back (default tab, matching the
     // scaffold's Biome config), so wiring a worker never reformats the file out from under lint.
     const manifestIndent = detectJsonIndent(manifestRaw);
-    const models = await readModels(root, io, manifest);
+    const diskModels = await readModels(root, io, manifest);
     const declaredTypeIds = Object.keys(manifest.types ?? {});
-    const { plans, skipped } = planWorkerScaffold(models, manifest.workers ?? [], declaredTypeIds, manifest.externalTaskTypes ?? []);
+    // Fuse on-disk models with any in-memory extras (code-first derived models — see
+    // `ScaffoldOptions.extraModels`), deduped by path with the IN-MEMORY model winning: a derived
+    // model whose path also exists on disk may be stale there (`--check`/`--no-models` never write
+    // it), so planning from the disk copy would miss newly added tasks and keep removed ones. This
+    // mirrors the precedence `collectAll` (gen.ts) gives the type-contract derivers.
+    const extraPaths = new Set((opts.extraModels ?? []).map((m) => m.path));
+    const models = [...diskModels.filter((m) => !extraPaths.has(m.path)), ...(opts.extraModels ?? [])];
+    const { plans, skipped } = planWorkerScaffold(models, manifest.workers ?? [], declaredTypeIds, manifest.externalTaskTypes ?? [], opts.inlineTaskTypes ?? []);
     const outcomes = [];
     const wired = [];
     for (const plan of plans) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@nanobpm/urban",
-	"version": "0.96.2",
+	"version": "0.96.3",
 	"description": "Urban: build and run code-first apps on Nano — runtime, derivation toolkit, and CLI in one. Author durable processes with @nanobpm/workflow (defineFlow), a typed datasource, forms, triggers and surfaces from a nano.app.json manifest, on Node or Deno.",
 	"license": "Apache-2.0",
 	"type": "module",
@@ -106,9 +106,9 @@
 		"@nanobpm/agentic": "^0.15.0",
 		"@nanobpm/nano-app-schema": "^0.11.0",
 		"@nanobpm/nano-sdk": "^1.2.5",
-		"@nanobpm/workflow": "^0.15.0",
+		"@nanobpm/workflow": "^0.15.1",
 		"bpmn-auto-layout": "^2.0.0-alpha.2",
-		"create-urban-app": "^0.15.2",
+		"create-urban-app": "^0.15.3",
 		"yaml": "^2.9.0"
 	},
 	"devDependencies": {

package/src/index.ts

@@ -31,6 +31,7 @@ export {
   declarativeToBpmn,
   declarativeToLayoutedBpmn,
   externalJobTypes,
+  inlineJobTypes,
   envelope,
   layoutBpmn,
   toBpmn,

package/src/toolkit/gen.ts

@@ -65,6 +65,16 @@ export interface GenResult {
   incomplete: boolean;
   /** Per-file model-derivation errors (empty on success). */
   modelErrors: ModelError[];
+  /** Job types of inline-handled (`w.run`) code-first steps — the set the app's in-process
+   *  Worker already serves (nano-ide#595). The worker-stub scaffolder skips these; empty for a
+   *  model-first app. */
+  inlineTaskTypes: string[];
+  /** The code-first models derived in-memory this run (`deriveModels().models`) — the
+   *  worker-stub scaffolder plans against these in addition to the on-disk models, since a
+   *  declared `models` block (e.g. `models.workflows`) suppresses the `resources/` convention
+   *  scan that would otherwise pick the written `.bpmn` up (nano-ide#595). Empty for a
+   *  model-first app. */
+  derivedModels: ModelSource[];
   /** Non-fatal spec-hygiene warnings (e.g. a requestBody schema shared by >1 operation). Empty on
    *  a clean spec. Surfaced by the CLI but never fail gen/check — advisory only. */
   warnings: string[];
@@ -333,7 +343,7 @@ export async function runGen(opts: GenOptions & { check?: boolean }): Promise<Ge
     }
   }
 
-  return { artifacts, drift, swept: swept.sort(), incomplete: derived.incomplete, modelErrors: derived.errors, warnings };
+  return { artifacts, drift, swept: swept.sort(), incomplete: derived.incomplete, modelErrors: derived.errors, inlineTaskTypes: derived.inlineTaskTypes, derivedModels: derived.models, warnings };
 }
 
 export { dirOf, join as joinPath };

package/src/toolkit/generate.test.ts

@@ -2,9 +2,13 @@ import { test } from "node:test";
 import assert from "node:assert/strict";
 import { generate } from "./generate.ts";
 import type { GenIO } from "./gen.ts";
+import { defineFlow, envelope } from "@nanobpm/workflow";
 
 /** In-memory filesystem mirroring gen.test.ts's memIO (IO-free, deterministic). */
-function memIO(files: Record<string, string>): GenIO & { files: Record<string, string> } {
+function memIO(
+  files: Record<string, string>,
+  modules: Record<string, Record<string, unknown>> = {},
+): GenIO & { files: Record<string, string> } {
   return {
     files,
     async readText(p) {
@@ -25,12 +29,28 @@ function memIO(files: Record<string, string>): GenIO & { files: Record<string, s
       }
       return [...names];
     },
+    async listSubdirs(p) {
+      const prefix = p.replace(/\/+$/, "") + "/";
+      const names = new Set<string>();
+      for (const f of Object.keys(files)) {
+        if (f.startsWith(prefix)) {
+          const rest = f.slice(prefix.length);
+          const slash = rest.indexOf("/");
+          if (slash > 0) names.add(rest.slice(0, slash));
+        }
+      }
+      return [...names];
+    },
     async exists(p) {
       return p in files;
     },
     async remove(p) {
       delete files[p];
     },
+    async importModule(p) {
+      if (!(p in modules)) throw new Error(`no module registered for ${p}`);
+      return modules[p];
+    },
   };
 }
 
@@ -133,3 +153,68 @@ test("generate keeps existing human-owned stubs (write-once, never clobbered)",
   assert.deepEqual(res.operationStubs.map((s) => s.status), ["kept"]);
   assert.deepEqual(res.missingStubs, []);
 });
+
+// --- code-first: w.run steps are inline-handled, so gen must never scaffold stubs for them ---
+
+const GreetIn = envelope("GreetIn", { who: "string" });
+const GreetOut = envelope("GreetOut", { message: "string" });
+
+/** The stock code-first template's flow: one inline-handled `w.run` step (nano-ide#595's repro). */
+const greetFlow = defineFlow("greet", { hello: { in: GreetIn, out: GreetOut } }, (w) => {
+  w.run("hello", async () => ({ message: "hi" }));
+});
+
+test("generate on a code-first app scaffolds NO stub for an inline w.run step (nano-ide#595)", async () => {
+  // The stock code-first app (create-urban-app --code-first): `greet:hello` is served by
+  // `w.run("hello", …)` and hosted in-process by main.ts's Worker. Scaffolding a throwing stub
+  // for it puts a second, always-failing worker on the same job type.
+  const io = memIO(
+    {
+      "/cf/nano.app.json": JSON.stringify({
+        id: "cf",
+        data: { default: "app" },
+        models: { workflows: ["workflows/*.ts"] },
+      }),
+      "/cf/workflows/greet.ts": "// derived in-memory via importModule stub",
+    },
+    { "/cf/workflows/greet.ts": { greet: greetFlow } },
+  );
+
+  const res = await generate({ root: "/cf", io });
+
+  assert.equal(res.incomplete, false);
+  assert.deepEqual(res.workerStubs, [], "no worker stub is scaffolded for an inline-handled step");
+  assert.deepEqual(res.wiredWorkers, [], "nothing is wired into workers[]");
+  assert.equal(res.manifestPatched, false, "the manifest is untouched");
+  assert.equal(io.files["/cf/workers/greet-hello/worker.ts"], undefined, "no throwing stub on disk");
+  const manifest = JSON.parse(io.files["/cf/nano.app.json"]);
+  assert.equal(manifest.workers, undefined, "workers[] stays undeclared");
+  // The model itself is still derived and written.
+  assert.ok(io.files["/cf/resources/processes/greet.bpmn"], "the derived .bpmn still lands");
+});
+
+test("generate on a code-first app still scaffolds a stub for an external w.task step", async () => {
+  // The other half of the split: only `w.run` steps are inline; a `w.task` step has no in-process
+  // handler, so it still needs its write-once stub.
+  const flow = defineFlow("orders", (w) => {
+    w.run("charge", async () => ({}));
+    w.task("sign"); // external worker
+  });
+  const io = memIO(
+    {
+      "/cf/nano.app.json": JSON.stringify({
+        id: "cf",
+        data: { default: "app" },
+        models: { workflows: ["workflows/*.ts"] },
+      }),
+      "/cf/workflows/orders.ts": "// derived in-memory via importModule stub",
+    },
+    { "/cf/workflows/orders.ts": { flow } },
+  );
+
+  const res = await generate({ root: "/cf", io });
+
+  assert.deepEqual(res.workerStubs.map((s) => s.taskType), ["orders:sign"]);
+  assert.ok(io.files["/cf/workers/orders-sign/worker.ts"], "external task gets its stub");
+  assert.equal(io.files["/cf/workers/orders-charge/worker.ts"], undefined, "inline step gets none");
+});

package/src/toolkit/generate.ts

@@ -52,7 +52,15 @@ export async function generate(opts: GenOptions & { check?: boolean }): Promise<
 
   const write = !opts.check;
   const scaffoldOpts = { root: opts.root, io: opts.io, manifestFile: opts.manifestFile, write };
-  const workers = await scaffoldWorkers(scaffoldOpts);
+  // Inline-handled (`w.run`) steps are already served by the app's in-process Worker — never
+  // scaffold a competing throwing stub for them (nano-ide#595). The derived models are also
+  // handed over: a code-first manifest's declared `models` block suppresses the resources/
+  // convention scan in readModels, so without them the scaffolder would plan from nothing.
+  const workers = await scaffoldWorkers({
+    ...scaffoldOpts,
+    inlineTaskTypes: res.inlineTaskTypes,
+    extraModels: res.derivedModels,
+  });
   const operations = await scaffoldOperations(scaffoldOpts);
 
   const missingStubs = [

package/src/toolkit/models.test.ts

@@ -157,3 +157,24 @@ test("deriveModels treats a genuine same-module re-export as one model, no error
   assert.deepEqual(d.errors, []);
   assert.equal(d.ids.length, 1);
 });
+
+test("deriveModels reports the inline-handled (w.run) task types alongside the model (nano-ide#595)", async () => {
+  // The worker-stub scaffolder consumes `inlineTaskTypes` to skip steps whose handler is hosted
+  // in-process by the flow's Worker — only `w.task` (external) steps may be scaffolded.
+  const mixed = defineFlow("orders", (w) => {
+    w.run("charge", async () => ({}));
+    w.task("sign"); // external — must NOT be reported inline
+    w.run("ship", async () => ({}));
+  });
+  const io = memIO(
+    { "/app/workflows/orders.ts": "// source" },
+    { "workflows/orders.ts": { mixed } },
+  );
+  const d = await deriveModels("/app", io, CODE_FIRST_MANIFEST);
+  assert.equal(d.incomplete, false);
+  assert.deepEqual(d.inlineTaskTypes.sort(), ["orders:charge", "orders:ship"]);
+  // A no-op derivation (no loader / no workflow files) reports an empty set, not undefined.
+  const noLoader = memIO({ "/app/workflows/orders.ts": "// source" });
+  delete noLoader.importModule;
+  assert.deepEqual((await deriveModels("/app", noLoader, CODE_FIRST_MANIFEST)).inlineTaskTypes, []);
+});

package/src/toolkit/models.ts

@@ -9,7 +9,7 @@
 // loader is absent — or the app authors its models directly (model-first) — derivation is a
 // no-op and the rest of `urban gen` proceeds on the authored/derived models unchanged.
 
-import { toDeployableBpmn } from "@nanobpm/workflow";
+import { inlineJobTypes, toDeployableBpmn } from "@nanobpm/workflow";
 import type { Workflow } from "@nanobpm/workflow";
 import type { DerivedArtifact } from "./artifact.ts";
 import type { GenIO } from "./gen.ts";
@@ -78,6 +78,13 @@ export interface DerivedModels {
   models: ModelSource[];
   /** Derived flow ids (used for the provenance-scoped stale sweep). */
   ids: string[];
+  /** Job types of inline-handled (`w.run`) steps across every derived declarative flow —
+   *  the set the app's in-process Worker already serves (nano-ide#595). The worker-stub
+   *  scaffolder skips these; only `w.task` (external) steps may be scaffolded. Empty when
+   *  derivation was a no-op (no loader / no workflow files) or all flows are imperative
+   *  (an imperative flow's steps run inside its single `:__orchestrate` job, which the
+   *  planner already skips). */
+  inlineTaskTypes: string[];
   /** Per-flow `{ id, kind, xml }` for the non-writing preview (`urban derive --stdout`). */
   list: DerivedModelInfo[];
   /** The output directory the artifacts were written into. */
@@ -101,6 +108,7 @@ function emptyDerived(outDir: string): DerivedModels {
     artifacts: [],
     models: [],
     ids: [],
+    inlineTaskTypes: [],
     list: [],
     outDir,
     attempted: false,
@@ -184,6 +192,7 @@ export async function deriveModels(
         const path = `${outDir}/${bpmnFilename(id)}`;
         out.artifacts.push({ path, content: xml });
         out.models.push({ path, xml });
+        if (value.kind === "declarative") out.inlineTaskTypes.push(...inlineJobTypes(value));
         out.list.push({ id, kind: value.kind, xml });
         out.ids.push(id);
       } catch (e) {

package/src/toolkit/scaffold/workers.test.ts

@@ -146,6 +146,19 @@ test("planWorkerScaffold: skips a task type declared external (out-of-process wo
   assert.equal(reasons["senior:review"], "external");
 });
 
+test("planWorkerScaffold: skips an inline-handled (w.run) task type — never stubs a hosted handler (nano-ide#595)", () => {
+  // A code-first `w.run` step's handler lives inline in the flow and is hosted by the in-process
+  // Worker; scaffolding a throwing stub for its job type would put a second, always-failing worker
+  // on the same job type. The derivation reports those types, and the planner must skip them.
+  const models = [
+    model("a.bpmn", "greet", serviceTask("hello", "greet:hello"), serviceTask("B", "greet:ship")),
+  ];
+  const { plans, skipped } = planWorkerScaffold(models, [], [], [], ["greet:hello"]);
+  assert.deepEqual(plans.map((p) => p.taskType), ["greet:ship"]);
+  const reasons = Object.fromEntries(skipped.map((s) => [s.taskType, s.reason]));
+  assert.equal(reasons["greet:hello"], "inline");
+});
+
 test("planWorkerScaffold: colliding slugs get a numeric suffix", () => {
   const m = model("a.bpmn", "p", serviceTask("A", "orders.charge"), serviceTask("B", "orders-charge"));
   const { plans } = planWorkerScaffold([m], [], []);
@@ -258,6 +271,58 @@ test("scaffoldWorkers is idempotent: a second --write run is a no-op", async ()
   assert.equal(JSON.stringify(io.files), snapshot, "files unchanged on re-run");
 });
 
+test("scaffoldWorkers skips inline-handled (w.run) task types — no stub, no wiring (nano-ide#595)", async () => {
+  const files = {
+    "/app/nano.app.json": JSON.stringify({
+      id: "demo",
+      models: { processes: ["processes/*.bpmn"] },
+    }),
+    "/app/processes/p.bpmn": model("p.bpmn", "greet",
+      serviceTask("hello", "greet:hello"),
+      serviceTask("B", "greet:notify"),
+    ).xml,
+  };
+  const io = memIO(files);
+  const run = await scaffoldWorkers({ root: "/app", io, write: true, inlineTaskTypes: ["greet:hello"] });
+  // Only the external (un-hosted) task is scaffolded; the inline one is skipped entirely.
+  assert.deepEqual(run.outcomes.map((o) => o.taskType), ["greet:notify"]);
+  assert.ok(run.skipped.some((s) => s.taskType === "greet:hello" && s.reason === "inline"));
+  assert.equal(io.files["/app/workers/greet-hello/worker.ts"], undefined, "inline task gets no stub");
+  const manifest = JSON.parse(io.files["/app/nano.app.json"]);
+  assert.ok(
+    !manifest.workers?.some((w: { taskType: string }) => w.taskType === "greet:hello"),
+    "inline task is never wired into workers[]",
+  );
+});
+
+test("scaffoldWorkers prefers an in-memory derived model over a stale disk copy at the same path (nano-ide#595)", async () => {
+  // `--check`/`--no-models` runs never write the derived `.bpmn`, so a derived model's path can
+  // hold a STALE disk copy. Planning from disk would miss newly added external tasks and keep
+  // removed ones. The in-memory model must win — the same precedence `collectAll` (gen.ts) gives
+  // the type-contract derivers.
+  const files = {
+    "/app/nano.app.json": JSON.stringify({
+      id: "demo",
+      models: { processes: ["processes/*.bpmn"] },
+    }),
+    // Stale disk copy: still has the REMOVED task, lacks the ADDED one.
+    "/app/processes/p.bpmn": model("p.bpmn", "p", serviceTask("Old", "t.removed")).xml,
+  };
+  const io = memIO(files);
+  const derived = model("processes/p.bpmn", "p", serviceTask("New", "t.added"));
+  const run = await scaffoldWorkers({ root: "/app", io, write: true, extraModels: [derived] });
+  // The fresh model is planned from: the added task is scaffolded, the removed one is not.
+  assert.deepEqual(run.outcomes.map((o) => o.taskType), ["t.added"]);
+  assert.ok(io.files["/app/workers/t-added/worker.ts"], "added task gets a stub");
+  assert.equal(io.files["/app/workers/t-removed/worker.ts"], undefined, "removed task gets no stub");
+  const manifest = JSON.parse(io.files["/app/nano.app.json"]);
+  assert.deepEqual(
+    manifest.workers?.map((w: { taskType: string }) => w.taskType),
+    ["t.added"],
+    "only the fresh model's task is wired",
+  );
+});
+
 test("scaffoldWorkers reads manifest.externalTaskTypes and skips those (never scaffolds/wires)", async () => {
   const files = {
     "/app/nano.app.json": JSON.stringify({

package/src/toolkit/scaffold/workers.ts

@@ -39,7 +39,7 @@ export interface WorkerStubPlan {
   manifestEntry: StubManifestEntry;
 }
 
-export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external";
+export type SkipReason = "already-wired" | "orchestrator" | "duplicate" | "external" | "inline";
 
 export interface SkippedWorker {
   taskType: string;
@@ -118,16 +118,20 @@ export function renderWorkerStub(
 /**
  * Plan write-once handler stubs from the models. A stub is planned for each service-task
  * `taskType` that is NOT already wired in the manifest, NOT the imperative orchestrator, NOT
- * declared external (serviced by an out-of-process worker), and not a duplicate of one already
- * planned. `declaredTypeIds` are the manifest `types` ids — an envelope `in`/`out` is typed only
- * when it names one (matching the worker-io deriver). `externalTaskTypes` are the manifest's
- * declared external task types, which the app owns the model for but deliberately does not host.
+ * declared external (serviced by an out-of-process worker), NOT inline-handled (a code-first
+ * `w.run` step whose handler the app's in-process Worker already serves — nano-ide#595), and
+ * not a duplicate of one already planned. `declaredTypeIds` are the manifest `types` ids — an
+ * envelope `in`/`out` is typed only when it names one (matching the worker-io deriver).
+ * `externalTaskTypes` are the manifest's declared external task types, which the app owns the
+ * model for but deliberately does not host. `inlineTaskTypes` are the flow-derived inline
+ * (`w.run`) job types (`deriveModels().inlineTaskTypes`).
  */
 export function planWorkerScaffold(
   models: ModelSource[],
   workers: ScaffoldWorker[] = [],
   declaredTypeIds: Iterable<string> = [],
   externalTaskTypes: Iterable<string> = [],
+  inlineTaskTypes: Iterable<string> = [],
 ): WorkerScaffoldPlan {
   const wired = new Set(
     workers
@@ -136,6 +140,7 @@ export function planWorkerScaffold(
   );
   const declared = new Set(declaredTypeIds);
   const external = new Set(externalTaskTypes);
+  const inline = new Set(inlineTaskTypes);
 
   const plans: WorkerStubPlan[] = [];
   const skipped: SkippedWorker[] = [];
@@ -153,6 +158,10 @@ export function planWorkerScaffold(
         skipped.push({ taskType, reason: "external" });
         continue;
       }
+      if (inline.has(taskType)) {
+        skipped.push({ taskType, reason: "inline" });
+        continue;
+      }
       if (wired.has(taskType)) {
         skipped.push({ taskType, reason: "already-wired" });
         continue;

package/src/toolkit/scaffold.ts

@@ -5,6 +5,7 @@
 
 import type { GenIO } from "./gen.ts";
 import { joinPath, readModels } from "./gen.ts";
+import type { ModelSource } from "./derivers/worker-io.ts";
 import {
   planWorkerScaffold,
   type ScaffoldWorker,
@@ -50,6 +51,22 @@ export interface ScaffoldOptions {
   manifestFile?: string;
   /** Apply changes (create files + patch manifest). Default false = dry-run. */
   write?: boolean;
+  /**
+   * Job types of inline-handled (`w.run`) code-first steps — the set the app's in-process
+   * Worker already serves (nano-ide#595). The planner skips these with reason `"inline"` so
+   * `urban gen` never scaffolds a throwing stub that competes with the real handler. Pass
+   * `deriveModels().inlineTaskTypes` (the `generate` composition does).
+   */
+  inlineTaskTypes?: Iterable<string>;
+  /**
+   * Extra in-memory models to plan against in addition to the on-disk ones `readModels`
+   * resolves (nano-ide#595). A code-first app's derived `.bpmn` lives under
+   * `resources/processes/`, which `readModels` does NOT resolve when the manifest declares a
+   * `models` block (e.g. `models.workflows`) without `models.processes` — a declared block
+   * suppresses the `resources/` convention. Pass `deriveModels().models` so the scaffolder
+   * plans from the same fused model set the type-contract derivers saw.
+   */
+  extraModels?: ModelSource[];
 }
 
 export type StubStatus = "created" | "would-create" | "kept";
@@ -87,14 +104,23 @@ export async function scaffoldWorkers(opts: ScaffoldOptions): Promise<ScaffoldRu
   // Preserve the manifest's own indentation when we patch it back (default tab, matching the
   // scaffold's Biome config), so wiring a worker never reformats the file out from under lint.
   const manifestIndent = detectJsonIndent(manifestRaw);
-  const models = await readModels(root, io, manifest);
+  const diskModels = await readModels(root, io, manifest);
   const declaredTypeIds = Object.keys(manifest.types ?? {});
 
+  // Fuse on-disk models with any in-memory extras (code-first derived models — see
+  // `ScaffoldOptions.extraModels`), deduped by path with the IN-MEMORY model winning: a derived
+  // model whose path also exists on disk may be stale there (`--check`/`--no-models` never write
+  // it), so planning from the disk copy would miss newly added tasks and keep removed ones. This
+  // mirrors the precedence `collectAll` (gen.ts) gives the type-contract derivers.
+  const extraPaths = new Set((opts.extraModels ?? []).map((m) => m.path));
+  const models = [...diskModels.filter((m) => !extraPaths.has(m.path)), ...(opts.extraModels ?? [])];
+
   const { plans, skipped } = planWorkerScaffold(
     models,
     manifest.workers ?? [],
     declaredTypeIds,
     manifest.externalTaskTypes ?? [],
+    opts.inlineTaskTypes ?? [],
   );
 
   const outcomes: StubOutcome[] = [];