@@ -0,0 +1,14 @@
+---
+'@object-ui/core': patch
+---
+
+fix(core): the console runs a stored action that leaves `type` to its default as a script action
+
+Clause-②: no
+Metadata-protocol: none
+
+`ActionSchema.type` defaults to `script`, but the console runs a stored action row as it was stored, not as the spec parses it. An action saved without `type`, such as the blank New skeleton in Studio or a row an older Studio build wrote, had its route resolved to its own name, matched no executor and was refused as "not executable".
+
+- **The action runner now reads a missing `type` as the spec's default** at the one place it picks the dispatch route. A typeless `{ name, body }` action and a typeless `{ name, operation: 'update', patch }` action both reach the registered `script` dispatch, which posts the platform action route.
+- **Unchanged:** an unknown `type` and a completely empty schema are still refused; a handler registered under the action's name still runs first; a typeless action that declares a runner key of its own (`navigate`, `api`, `endpoint`, `onClick`, `redirect`, an explicit `reload` or `close`) still runs on that key.
+- No writer adds `type`, and no stored row changes.
@@ -1075,6 +1075,61 @@ function crossesObjectBoundary(viewName: string, contextObject: string | undefin
   return !viewName.startsWith(`${contextObject}.`);
 }
 
+/**
+ * Does the action declare a behaviour the runner performs itself, without a
+ * dispatch route — a `navigate`, an `api` / `endpoint` call, an `onClick`, a
+ * `redirect`, or an EXPLICIT `reload` / `close`?
+ *
+ * These are runner keys, not `ActionSchema` keys: the legacy fallbacks of
+ * `dispatchCollected` and `executeActionSchema` run them. `reload` / `close`
+ * default to true downstream, so only an explicit `true` counts as declared
+ * intent — otherwise every empty schema would look like it asked for one.
+ */
+function declaresRunnerBehavior(action: ActionDef): boolean {
+  return !!(action.navigate || action.api || action.endpoint || action.onClick || action.redirect)
+    || action.reload === true || action.close === true;
+}
+
+/**
+ * The route an action is dispatched on — the key `dispatchCollected` looks up
+ * a registered handler and a built-in executor under. This is the ONE place
+ * the runner picks it:
+ *
+ * 1. The authored `type`, else the `action:*` block's `actionType`.
+ * 2. Neither: the action's `name`, when a handler is registered under it — the
+ *    by-name dispatch hosts wire custom actions through, and the leg an
+ *    `action:button` that declares no `actionType` lands on — or when the
+ *    action declares a runner behaviour of its own
+ *    ({@link declaresRunnerBehavior}), which the legacy fallbacks run.
+ * 3. Otherwise a named action is a declaration that left `type` to its
+ *    default: `@objectstack/spec`'s `ActionSchema.type` is
+ *    `.default('script')`. A stored row reaches the console UNPARSED
+ *    (objectstack-ai/objectstack#3903), so nothing has materialized that
+ *    default; it is applied here, where the route is read, and ⛔ never by
+ *    writing `type` into each producer. Without it the action fell back to its
+ *    NAME, matched no executor, and was refused as "not executable" — a
+ *    spec-valid script action, dead in the console.
+ * 4. Nothing named: `''`, which `executeActionSchema` refuses (objectui#2960).
+ *
+ * An unknown `type` is step 1's answer and stays unknown: it is never read as
+ * the default, so it is refused as before.
+ */
+function resolveDispatchType(action: ActionDef, hasHandler: (name: string) => boolean): string {
+  const declared = action.type || action.actionType;
+  if (declared) return declared;
+  const name = action.name || '';
+  if (!name || hasHandler(name) || declaresRunnerBehavior(action)) return name;
+  return SPEC_DEFAULT_ACTION_TYPE;
+}
+
+/**
+ * `ActionSchema.type`'s default in `@objectstack/spec` — the platform action
+ * route. Read by {@link resolveDispatchType} alone;
+ * `ActionRunner.specDefaultType-26879.test.ts` holds it equal to the type the
+ * spec materializes on a typeless action.
+ */
+const SPEC_DEFAULT_ACTION_TYPE: RunnableActionType = 'script';
+
 /**
  * Is this the declarative single-record field write?
  *
@@ -1452,8 +1507,9 @@ export class ActionRunner {
       // two apart. Dev-only, warn-once, changes nothing.
       warnOnDeprecatedObjectParams(action);
 
-      // Resolve the action type
-      const actionType = action.type || action.actionType || action.name || '';
+      // Resolve the dispatch route — a typeless declaration takes the spec's
+      // default `type` (see `resolveDispatchType`).
+      const actionType = resolveDispatchType(action, (name) => this.handlers.has(name));
 
       // Conditional execution. Ask "is a `condition` gate DECLARED?" — not "is
       // the raw value truthy?" (objectui#3872). Truthiness cannot answer that
@@ -2560,13 +2616,9 @@ export class ActionRunner {
    */
   private async executeActionSchema(action: ActionDef): Promise<ActionResult> {
     const hasApi = !!(action.api || action.endpoint);
-    // `reload`/`close` default to true downstream, so only an EXPLICIT `true`
-    // counts as declared intent — otherwise every empty schema would look like
-    // it asked for a reload and slip back through this guard.
-    const declaresBehavior =
-      hasApi || !!action.onClick || !!action.redirect
-      || action.reload === true || action.close === true;
-    if (!declaresBehavior) {
+    // Only an EXPLICIT `reload`/`close` counts (see `declaresRunnerBehavior`),
+    // or every empty schema would slip back through this guard.
+    if (!declaresRunnerBehavior(action)) {
       const label = action.name || action.type || action.actionType || 'action';
       return {
         success: false,
 
@@ -0,0 +1,183 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * A stored action without `type` runs on the spec's default route
+ * (objectstack-ai/objectstack#26879).
+ *
+ * `@objectstack/spec`'s `ActionSchema.type` is `.default('script')`, but the
+ * console runs the stored row, not its parse: a row rehydrated UNPARSED
+ * carries no `type` at all. The runner used to resolve such an action's route
+ * to its NAME, match no executor, and refuse it as "not executable" — so a
+ * spec-valid script action that Studio's New skeleton or an older Studio build
+ * stored without `type` was dead in the console. The runner now reads the
+ * missing `type` as the spec's default, at the one place it picks the route
+ * (`resolveDispatchType`).
+ *
+ * Pinned here:
+ *  1. A typeless `{ name, body }` and a typeless `{ name, operation: 'update',
+ *     patch }` both reach the registered `script` dispatch — the REAL
+ *     `createServerActionHandler`, so the URL that leaves the client is what is
+ *     asserted.
+ *  2. The default is the SPEC's: a typeless action takes the route named by
+ *     the `type` that `ActionSchema` materializes on it.
+ *  3. What the default must not swallow: an unknown `type` and a completely
+ *     empty schema are still refused, a handler registered under the action's
+ *     name still outranks the default, and a runner-own key (`redirect`) still
+ *     runs on its legacy leg.
+ */
+
+import { describe, it, expect, vi } from 'vitest';
+import { ActionSchema } from '@objectstack/spec/ui';
+import { ActionRunner, type ActionDef, type ActionRunnerHandler } from '../ActionRunner';
+import { createServerActionHandler, type ServerActionFetch } from '../serverActionHandler';
+
+/** A fetch stub answering the route's success envelope. */
+function okFetch() {
+  return vi.fn(async () => ({ ok: true, status: 200, json: async () => ({ success: true, data: { ok: true } }) }));
+}
+
+/** A runner wired as a console host wires one: the server-action dispatch under `script`. */
+function wireRunner(fetch: ReturnType<typeof okFetch>) {
+  const runner = new ActionRunner({});
+  runner.registerHandler(
+    'script',
+    createServerActionHandler({ fetch: fetch as unknown as ServerActionFetch }),
+  );
+  return runner;
+}
+
+/** A stored script action as New's skeleton or an older Studio build left it: no `type`. */
+const TYPELESS_BODY_ACTION: ActionDef = {
+  name: 'run_script',
+  label: 'Run script',
+  objectName: 'tasks',
+  body: { language: 'expression', source: 'true' },
+};
+
+/** A stored declarative update with no `type`. */
+const TYPELESS_UPDATE_ACTION: ActionDef = {
+  name: 'mark_done',
+  label: 'Mark Done',
+  objectName: 'tasks',
+  operation: 'update',
+  patch: { status: 'done' },
+};
+
+describe('a stored action without `type` runs on the script route', () => {
+  it('runs a typeless `{ name, body }` action on the platform action route', async () => {
+    const fetch = okFetch();
+    const runner = wireRunner(fetch);
+
+    const result = await runner.execute({ ...TYPELESS_BODY_ACTION, params: { recordId: 'rec_1' } as never });
+
+    expect(result.success).toBe(true);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    const [url, init] = (fetch as any).mock.calls[0];
+    expect(url).toBe('/api/v1/actions/tasks/run_script');
+    expect(init.method).toBe('POST');
+  });
+
+  it("runs a typeless `{ name, operation: 'update', patch }` action on the platform action route", async () => {
+    const fetch = okFetch();
+    const runner = wireRunner(fetch);
+
+    const result = await runner.execute({ ...TYPELESS_UPDATE_ACTION, params: { recordId: 'rec_2' } as never });
+
+    expect(result.success).toBe(true);
+    expect(fetch).toHaveBeenCalledTimes(1);
+    expect((fetch as any).mock.calls[0][0]).toBe('/api/v1/actions/tasks/mark_done');
+  });
+
+  it("asks the script dispatch's early refusal for a typeless action, as for a typed one", async () => {
+    // The route picked once is the route asked before any input
+    // (`refusalBeforeInput`) and the route dispatched on.
+    const dispatch = vi.fn(async () => ({ success: true })) as unknown as ActionRunnerHandler;
+    const refuseBeforeInput = vi.fn(() => ({ error: 'Select one record' }));
+    dispatch.refuseBeforeInput = refuseBeforeInput;
+    const runner = new ActionRunner({});
+    runner.registerHandler('script', dispatch);
+
+    const result = await runner.execute({ ...TYPELESS_BODY_ACTION });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe('Select one record');
+    expect(refuseBeforeInput).toHaveBeenCalledTimes(1);
+    expect(dispatch).not.toHaveBeenCalled();
+  });
+});
+
+describe("the default is the spec's", () => {
+  it('takes the route named by the `type` ActionSchema materializes on a typeless action', async () => {
+    const parsed = ActionSchema.safeParse(TYPELESS_BODY_ACTION);
+    expect(parsed.error).toBeUndefined();
+    const specType = parsed.success ? parsed.data.type : undefined;
+    expect(typeof specType).toBe('string');
+
+    const runner = new ActionRunner({});
+    const reached: string[] = [];
+    for (const type of ['script', 'url', 'modal', 'flow', 'api', 'form', 'navigation']) {
+      runner.registerHandler(type, async () => {
+        reached.push(type);
+        return { success: true };
+      });
+    }
+
+    const result = await runner.execute({ ...TYPELESS_BODY_ACTION });
+
+    expect(result.success).toBe(true);
+    expect(reached).toEqual([specType]);
+  });
+});
+
+describe('what the default does not swallow', () => {
+  it('still refuses an action whose `type` names no route', async () => {
+    const script = vi.fn(async () => ({ success: true }));
+    const runner = new ActionRunner({});
+    runner.registerHandler('script', script);
+
+    const result = await runner.execute({ type: 'convert_lead', name: 'convert_lead' });
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('convert_lead');
+    expect(script).not.toHaveBeenCalled();
+  });
+
+  it('still refuses a completely empty schema', async () => {
+    const script = vi.fn(async () => ({ success: true }));
+    const runner = new ActionRunner({});
+    runner.registerHandler('script', script);
+
+    const result = await runner.execute({});
+
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not executable');
+    expect(script).not.toHaveBeenCalled();
+  });
+
+  it('runs a handler registered under the action name ahead of the default', async () => {
+    const script = vi.fn(async () => ({ success: true }));
+    const byName = vi.fn(async () => ({ success: true }));
+    const runner = new ActionRunner({});
+    runner.registerHandler('script', script);
+    runner.registerHandler('run_script', byName);
+
+    const result = await runner.execute({ ...TYPELESS_BODY_ACTION });
+
+    expect(result.success).toBe(true);
+    expect(byName).toHaveBeenCalledTimes(1);
+    expect(script).not.toHaveBeenCalled();
+  });
+
+  it('runs a typeless named action that declares a `redirect` on its legacy leg', async () => {
+    const script = vi.fn(async () => ({ success: true }));
+    const runner = new ActionRunner({});
+    runner.registerHandler('script', script);
+
+    const result = await runner.execute({ name: 'go_home', redirect: '/home' });
+
+    expect(result.success).toBe(true);
+    expect(result.redirect).toBe('/home');
+    expect(script).not.toHaveBeenCalled();
+  });
+});