diff --git a/‎.changeset/22599-verify-hooks-run-delete-answer.md‎
Lines changed: 21 additions & 0 deletions b/‎.changeset/22599-verify-hooks-run-delete-answer.md‎
Lines changed: 21 additions & 0 deletions
diff --git a/‎packages/verify/src/handle.delete-answer.test.ts‎
Lines changed: 56 additions & 0 deletions b/‎packages/verify/src/handle.delete-answer.test.ts‎
Lines changed: 56 additions & 0 deletions
diff --git a/‎packages/verify/src/handle.ts‎
Lines changed: 37 additions & 5 deletions b/‎packages/verify/src/handle.ts‎
Lines changed: 37 additions & 5 deletions
@@ -0,0 +1,21 @@
+---
+'@objectstack/verify': minor
+---
+
+fix(verify)!: `hooks.run(object, 'delete', …)` resolves with what the engine's `delete` answers, not with a row
+
+Clause-②: no (narrowing)
+
+<!-- adr-0087: not-required (runtime-interface-only packages/verify/src/handle.ts#VerifyHandle) One TypeScript-only declaration moves, and it is not metadata: the `hooks.run` member of the published `VerifyHandle` interface, whose `delete` answer narrows from a row to the engine's own declared delete answer. No spec key, authorable spelling, Zod schema, export name or stored shape moves, and no runtime behaviour changes, so `objectstack migrate meta` has nothing to rewrite. The party affected is a TypeScript author who read a field of a delete's answer: the compiler names that read at their own call site, and the body says what to assert instead. The other categories are closed on facts: the package publishes (not `unpublished`); no ADR-0087 id covers a test handle's return type, and this diff adds none (not `registered` / `already-registered`); and the member was typed with the named `EngineRow` at the merge base, which predicate 4 reads as concrete, not erased (not `type-surface-only`). -->
+
+**BREAKING** for TypeScript code that reads the answer of a `hooks.run` delete. It ships as `minor` under the launch-window convention for breaking changes. No runtime behaviour changes.
+
+`hooks.run(object, 'delete', { id }, opts)`, for a person (`{ as }`) and for the system (`{ system: true }`), was declared to resolve with a row (`Promise<EngineRow>`). The engine's `delete` answers `true` for the row it removed. So a test that read a field of the answer type-checked, and then read `undefined`.
+
+**What `hooks.run` declares now.** Both overloads are generic over the operation.
+
+- An `insert` or an `update` resolves with the row, as before.
+- A `delete` resolves with the engine's own declared delete answer, `boolean | number`. It is read off `ObjectQL['delete']` rather than re-declared, and a `hooks.run` delete, which is always by id, answers `true`.
+- A call whose operation is the union `'insert' | 'update' | 'delete'` still type-checks, and resolves with the union of the answers.
+
+**If your code read a field of a delete's answer.** That read was always `undefined` at run time, and it is now a compile error. Assert the answer itself, `expect(await stack.hooks.run(object, 'delete', { id }, opts)).toBe(true)`. If the test needs the deleted row, read it with `stack.rows(object, { id })` before the delete.
@@ -0,0 +1,56 @@
+// Copyright (c) 2026 ObjectStack. Licensed under the Apache-2.0 license.
+//
+// [#22599] What `hooks.run` declares each write resolves with. A delete
+// resolves with what the engine's `delete` answers (`true` for the row it
+// removed), never with a row: typed as a row, a test that read a field of a
+// delete's answer type-checked and then read `undefined`.
+//
+// A TYPE test. Its assertions are checked by the package's test-layer tsc
+// program (`pnpm --filter @objectstack/verify typecheck`, which runs
+// `check:test-typecheck` over `tsconfig.test.json`); at run time they are
+// no-ops, and nothing here boots a stack.
+
+import { describe, it, expectTypeOf } from 'vitest';
+import type { ObjectQL } from '@objectstack/objectql';
+
+import type { EngineRow, VerifyHandle } from './handle.js';
+
+/** The engine's own declaration, the one the handle reads its delete answer off. */
+type EngineDeleteAnswer = Awaited<ReturnType<ObjectQL['delete']>>;
+
+/** Never called: each call is here to be resolved against the overloads, not run. */
+function answersOf(hooks: VerifyHandle['hooks'], anyOperation: 'insert' | 'update' | 'delete') {
+  return {
+    personDelete: hooks.run('obj', 'delete', { id: 'x' }, { as: 'token' }),
+    systemDelete: hooks.run('obj', 'delete', { id: 'x' }, { system: true }),
+    personInsert: hooks.run('obj', 'insert', { name: 'x' }, { as: 'token' }),
+    systemInsert: hooks.run('obj', 'insert', { name: 'x' }, { system: true }),
+    personUpdate: hooks.run('obj', 'update', { id: 'x' }, { as: 'token' }),
+    systemUpdate: hooks.run('obj', 'update', { id: 'x' }, { system: true }),
+    unionOperation: hooks.run('obj', anyOperation, { id: 'x' }, { as: 'token' }),
+  };
+}
+type Answers = { [K in keyof ReturnType<typeof answersOf>]: Awaited<ReturnType<typeof answersOf>[K]> };
+
+describe("hooks.run(object, 'delete', …) resolves with what the engine answers", () => {
+  it('a delete, by a person or by the system, resolves with the engine delete answer', () => {
+    expectTypeOf<Answers['personDelete']>().toEqualTypeOf<EngineDeleteAnswer>();
+    expectTypeOf<Answers['systemDelete']>().toEqualTypeOf<EngineDeleteAnswer>();
+  });
+
+  it("a delete's answer is not a row: reading a field of it does not type-check", () => {
+    expectTypeOf<Answers['personDelete']>().not.toHaveProperty('id');
+    expectTypeOf<Answers['systemDelete']>().not.toHaveProperty('id');
+  });
+
+  it('an insert or an update still resolves with the row', () => {
+    expectTypeOf<Answers['personInsert']>().toEqualTypeOf<EngineRow>();
+    expectTypeOf<Answers['systemInsert']>().toEqualTypeOf<EngineRow>();
+    expectTypeOf<Answers['personUpdate']>().toEqualTypeOf<EngineRow>();
+    expectTypeOf<Answers['systemUpdate']>().toEqualTypeOf<EngineRow>();
+  });
+
+  it('an operation of the union type resolves with the union of the answers', () => {
+    expectTypeOf<Answers['unionOperation']>().toEqualTypeOf<EngineRow | EngineDeleteAnswer>();
+  });
+});
@@ -107,6 +107,26 @@ export type EngineRow = Record<string, any>;
  */
 type AutomationCondition = Parameters<AutomationEngine['evaluateCondition']>[0];
 
+/**
+ * [#22599] What the engine's `delete` answers: the method's own declared
+ * return type, read off it rather than re-declared here, so the door promises
+ * exactly what the engine promises. The engine declares `boolean | number`:
+ * whether a by-id delete removed its row, or how many rows a predicate delete
+ * removed. Every `hooks.run` delete is by id, so it answers `true` for the
+ * row it removed (a row that is not there is refused before the driver
+ * runs). It is never the row: a test that needs the deleted row reads it
+ * before the delete.
+ */
+type EngineDeleteAnswer = Awaited<ReturnType<ObjectQL['delete']>>;
+
+/**
+ * [#22599] What one `hooks.run` write resolves with, keyed on its operation:
+ * the row the engine answers for an `insert` or an `update`, and
+ * {@link EngineDeleteAnswer} for a `delete`. Distributive, so a call whose
+ * `operation` is the union type resolves with the union of the answers.
+ */
+type HookWriteAnswer<Op extends 'insert' | 'update' | 'delete'> = Op extends 'delete' ? EngineDeleteAnswer : EngineRow;
+
 /**
  * The refusal a dispatcher-door method (`flows.*`, `actions.run`) throws when
  * the route answered a 4xx/5xx — the route's own ADR-0112 envelope, carried
@@ -254,6 +274,10 @@ export interface VerifyHandle {
      * engine's own error: assert on its `code` (and `statusCode`), never on
      * the message alone.
      *
+     * [#22599] An `insert` or an `update` resolves with the row the engine
+     * answers. A `delete` resolves with what the engine's `delete` answers,
+     * `true` for the row it removed, and never with the row.
+     *
      * `update` and `delete` address the row by `input.id`. The caller is a
      * person (`{ as }`, this overload) or the system (`{ system: true }`,
      * the next one), never both.
@@ -264,12 +288,12 @@ export interface VerifyHandle {
      * body })` with no token. That route hands the engine its own guest
      * context, keeps only the fields the form collects, and answers `{ id }`.
      */
-    run(
+    run<Op extends 'insert' | 'update' | 'delete'>(
       object: string,
-      operation: 'insert' | 'update' | 'delete',
+      operation: Op,
       input: EngineRow,
       opts: AsUser,
-    ): Promise<EngineRow>;
+    ): Promise<HookWriteAnswer<Op>>;
     /**
      * [#22301] The same three writes as the SYSTEM principal ({@link AsSystem}):
      * the engine calls above with `context: { isSystem: true }`, the write an
@@ -289,7 +313,12 @@ export interface VerifyHandle {
      * so it fires no record-change flow. Insert through `seed` for end-state
      * fixture data, and through this door for a write the app should react to.
      */
-    run(object: string, operation: 'insert' | 'update' | 'delete', input: EngineRow, opts: AsSystem): Promise<EngineRow>;
+    run<Op extends 'insert' | 'update' | 'delete'>(
+      object: string,
+      operation: Op,
+      input: EngineRow,
+      opts: AsSystem,
+    ): Promise<HookWriteAnswer<Op>>;
     /**
      * [#22301] A PREDICATE update: one payload written to every row `where`
      * selects. This is the engine's own predicate path, `update(object, data,
@@ -694,7 +723,10 @@ export async function createHandle(kernel: ObjectKernel, origin: string): Promis
     hooks: {
       // Parameters annotated because the member is overloaded (an overload
       // set gives no contextual parameter types); the return type is left to
-      // inference, as it was before the overload.
+      // inference, as it was before the overload. [#22599] Inference gives
+      // `Promise<any>` (the engine's `insert` declares `any`), so tsc does not
+      // relate each `case` below to its overload's answer: each returns the
+      // engine call unchanged, the call `HookWriteAnswer` reads its types off.
       async run(object: string, operation: 'insert' | 'update' | 'delete', input: EngineRow, opts: AsUser | AsSystem) {
         // The call's own shape is judged before anyone is resolved: a
         // malformed call is refused for its own reason, not for whatever the