@loopstack/testing-examples 0.1.0 → 0.2.0

package/README.md

@@ -1,19 +1,42 @@
 ---
-title: Testing Examples (placeholder)
-description: Placeholder for workflow testing examples in Loopstack — @loopstack/testing fixtures, transition assertions, mocked LLM responses (coming soon)
+title: Testing Examples
+description: Runnable workflow-testing examples for Loopstack — runWorkflow() in-process workflow tests with scripted HITL answers, parkView() park assertions, coverage() gates, testTool() tool unit tests, fixture auto record/replay, and createContractFake() DI fakes. Companion package to the Testing guide.
 ---
 
 # @loopstack/testing-examples
 
-> Workflow testing examples for the [Loopstack](https://loopstack.ai) automation framework. **Placeholder — examples coming soon.**
+> Runnable testing examples for the [Loopstack](https://loopstack.ai) automation framework — the patterns from the [Testing guide](https://loopstack.ai/docs/build/testing) and [Testing Methodology](https://loopstack.ai/docs/build/testing-methodology) as working code.
 
-This module is reserved for future workflow-testing examples:
+The example under test is a small deterministic triage flow (`src/triage/`): a `classify_ticket` tool grades a support ticket, the workflow presents the severity as a yes/no approval prompt, then waits for the human decision. No LLM — the whole flow is deterministic, so every test is exact.
 
-- Using `@loopstack/testing` fixtures
-- Asserting on transitions and final state
-- Mocking LLM responses for deterministic tests
+Scenarios are named for the acceptance criterion they check (`it('C1: …')`), so the test report reads as a criteria matrix — the discipline from the methodology guide.
 
-Track progress in the [Loopstack GitHub repo](https://github.com/loopstack-ai/loopstack/issues).
+## What each spec demonstrates
+
+| Spec                                  | Pattern                                                                                                                                                                                                           |
+| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `classify-ticket.tool.spec.ts`        | **Tool unit test** — `testTool().forTool(...)`, assert on the envelope data (the `resultSchema` is validated by `call()`)                                                                                         |
+| `triage-ticket.workflow.spec.ts`      | **In-process workflow test** — `runWorkflow()` with scripted `answers`; outcome assertions on `status`/`path`/`result`/`document()`; `parkView()` for the human touchpoint; a `coverage()` gate closing the suite |
+| `triage-ticket-replay.spec.ts`        | **Record/replay** — the `fixture:` option (auto record/replay, CI-guarded) as the default, plus an inline `replay()` fixture for fully-scripted determinism                                                       |
+| `triage-ticket-contract-fake.spec.ts` | **Contract fake** — `createContractFake()` substitutes the tool with a `resultSchema`-validated response and asserts how the workflow called it                                                                   |
+
+Run them:
+
+```bash
+npm test
+```
+
+## Recording fixtures from live runs
+
+The `fixture:` option records a fresh fixture when the file is missing and replays it when present. Record one from a real run:
+
+```bash
+npm run start:dev                                    # start the backend
+loopstack run triage_ticket --arg text="Production is down!" --trace
+loopstack runs <run-id> --record src/triage/__tests__/__recordings__/triage.json
+```
+
+Replay is transition-scoped: recordings are matched by the transition they were captured in, then consumed in sequence. Each entry's metadata (`tool`, `workflow`, `transition`, `args`, and `config` when present) is **asserted** against the actual call — when the outgoing args or config drift from the recording the run **fails** with a drift error naming the tool and both values, the signal to re-validate live and re-record. In CI a missing fixture is an error (not a silent live run) unless `LOOPSTACK_RECORD=1` is set.
 
 ## About
 

package/dist/index.d.ts

@@ -1,2 +1,3 @@
 export * from './testing-examples.module';
+export * from './triage';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,UAAU,CAAC"}

package/dist/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./testing-examples.module"), exports);
+__exportStar(require("./triage"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4DAA0C"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4DAA0C;AAC1C,2CAAyB"}

package/dist/testing-examples.module.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"testing-examples.module.d.ts","sourceRoot":"","sources":["../src/testing-examples.module.ts"],"names":[],"mappings":"AAGA,qBAKa,qBAAqB;CAAG"}
+{"version":3,"file":"testing-examples.module.d.ts","sourceRoot":"","sources":["../src/testing-examples.module.ts"],"names":[],"mappings":"AAKA,qBAOa,qBAAqB;CAAG"}

package/dist/testing-examples.module.js

@@ -9,14 +9,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TestingExamplesModule = void 0;
 const common_1 = require("@nestjs/common");
 const common_2 = require("@loopstack/common");
+const classify_ticket_tool_1 = require("./triage/classify-ticket.tool");
+const triage_ticket_workflow_1 = require("./triage/triage-ticket.workflow");
 let TestingExamplesModule = class TestingExamplesModule {
 };
 exports.TestingExamplesModule = TestingExamplesModule;
 exports.TestingExamplesModule = TestingExamplesModule = __decorate([
     (0, common_2.StudioApp)({
         title: 'Testing Examples',
-        workflows: [],
+        workflows: [triage_ticket_workflow_1.TriageTicketWorkflow],
     }),
-    (0, common_1.Module)({})
+    (0, common_1.Module)({
+        providers: [triage_ticket_workflow_1.TriageTicketWorkflow, classify_ticket_tool_1.ClassifyTicketTool],
+    })
 ], TestingExamplesModule);
 //# sourceMappingURL=testing-examples.module.js.map

package/dist/testing-examples.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"testing-examples.module.js","sourceRoot":"","sources":["../src/testing-examples.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,8CAA8C;AAOvC,IAAM,qBAAqB,GAA3B,MAAM,qBAAqB;CAAG,CAAA;AAAxB,sDAAqB;gCAArB,qBAAqB;IALjC,IAAA,kBAAS,EAAC;QACT,KAAK,EAAE,kBAAkB;QACzB,SAAS,EAAE,EAAE;KACd,CAAC;IACD,IAAA,eAAM,EAAC,EAAE,CAAC;GACE,qBAAqB,CAAG"}
+{"version":3,"file":"testing-examples.module.js","sourceRoot":"","sources":["../src/testing-examples.module.ts"],"names":[],"mappings":";;;;;;;;;AAAA,2CAAwC;AACxC,8CAA8C;AAC9C,wEAAmE;AACnE,4EAAuE;AAShE,IAAM,qBAAqB,GAA3B,MAAM,qBAAqB;CAAG,CAAA;AAAxB,sDAAqB;gCAArB,qBAAqB;IAPjC,IAAA,kBAAS,EAAC;QACT,KAAK,EAAE,kBAAkB;QACzB,SAAS,EAAE,CAAC,6CAAoB,CAAC;KAClC,CAAC;IACD,IAAA,eAAM,EAAC;QACN,SAAS,EAAE,CAAC,6CAAoB,EAAE,yCAAkB,CAAC;KACtD,CAAC;GACW,qBAAqB,CAAG"}

package/dist/triage/approval-prompt.document.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+export declare const ApprovalPromptSchema: z.ZodObject<{
+    question: z.ZodString;
+    severity: z.ZodEnum<{
+        high: "high";
+        normal: "normal";
+    }>;
+    answer: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+export type ApprovalPromptType = z.infer<typeof ApprovalPromptSchema>;
+export declare class ApprovalPromptDocument {
+    question: string;
+    severity: 'high' | 'normal';
+    answer?: string;
+}
+//# sourceMappingURL=approval-prompt.document.d.ts.map

package/dist/triage/approval-prompt.document.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-prompt.document.d.ts","sourceRoot":"","sources":["../../src/triage/approval-prompt.document.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,eAAO,MAAM,oBAAoB;;;;;;;kBAMtB,CAAC;AAEZ,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAQtE,qBAIa,sBAAsB;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC5B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB"}

package/dist/triage/approval-prompt.document.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApprovalPromptDocument = exports.ApprovalPromptSchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("@loopstack/common");
+exports.ApprovalPromptSchema = zod_1.z
+    .object({
+    question: zod_1.z.string(),
+    severity: zod_1.z.enum(['high', 'normal']),
+    answer: zod_1.z.string().optional(),
+})
+    .strict();
+let ApprovalPromptDocument = class ApprovalPromptDocument {
+    question;
+    severity;
+    answer;
+};
+exports.ApprovalPromptDocument = ApprovalPromptDocument;
+exports.ApprovalPromptDocument = ApprovalPromptDocument = __decorate([
+    (0, common_1.Document)({
+        schema: exports.ApprovalPromptSchema,
+        widget: { widget: 'confirm-prompt', options: { transition: 'approve' } },
+    })
+], ApprovalPromptDocument);
+//# sourceMappingURL=approval-prompt.document.js.map

package/dist/triage/approval-prompt.document.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"approval-prompt.document.js","sourceRoot":"","sources":["../../src/triage/approval-prompt.document.ts"],"names":[],"mappings":";;;;;;;;;AAAA,6BAAwB;AACxB,8CAA6C;AAEhC,QAAA,oBAAoB,GAAG,OAAC;KAClC,MAAM,CAAC;IACN,QAAQ,EAAE,OAAC,CAAC,MAAM,EAAE;IACpB,QAAQ,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACpC,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CAC9B,CAAC;KACD,MAAM,EAAE,CAAC;AAcL,IAAM,sBAAsB,GAA5B,MAAM,sBAAsB;IACjC,QAAQ,CAAS;IACjB,QAAQ,CAAoB;IAC5B,MAAM,CAAU;CACjB,CAAA;AAJY,wDAAsB;iCAAtB,sBAAsB;IAJlC,IAAA,iBAAQ,EAAC;QACR,MAAM,EAAE,4BAAoB;QAC5B,MAAM,EAAE,EAAE,MAAM,EAAE,gBAAgB,EAAE,OAAO,EAAE,EAAE,UAAU,EAAE,SAAS,EAAE,EAAE;KACzE,CAAC;GACW,sBAAsB,CAIlC"}

package/dist/triage/classify-ticket.tool.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+import { BaseTool, ToolEnvelope } from '@loopstack/common';
+declare const ClassifyTicketSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strict>;
+type ClassifyTicketArgs = z.infer<typeof ClassifyTicketSchema>;
+export interface ClassificationResult {
+    severity: 'high' | 'normal';
+    reason: string;
+}
+export declare const ClassificationResultSchema: z.ZodObject<{
+    severity: z.ZodEnum<{
+        high: "high";
+        normal: "normal";
+    }>;
+    reason: z.ZodString;
+}, z.core.$strict>;
+export declare class ClassifyTicketTool extends BaseTool<ClassifyTicketArgs, object, ClassificationResult> {
+    protected handle(args: ClassifyTicketArgs): Promise<ToolEnvelope<ClassificationResult>>;
+}
+export {};
+//# sourceMappingURL=classify-ticket.tool.d.ts.map

package/dist/triage/classify-ticket.tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-ticket.tool.d.ts","sourceRoot":"","sources":["../../src/triage/classify-ticket.tool.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,QAAQ,EAAQ,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEjE,QAAA,MAAM,oBAAoB;;kBAIf,CAAC;AAEZ,KAAK,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAE/D,MAAM,WAAW,oBAAoB;IACnC,QAAQ,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC5B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,eAAO,MAAM,0BAA0B;;;;;;kBAGrC,CAAC;AAIH,qBAOa,kBAAmB,SAAQ,QAAQ,CAAC,kBAAkB,EAAE,MAAM,EAAE,oBAAoB,CAAC;cAChF,MAAM,CAAC,IAAI,EAAE,kBAAkB,GAAG,OAAO,CAAC,YAAY,CAAC,oBAAoB,CAAC,CAAC;CAQ9F"}

package/dist/triage/classify-ticket.tool.js

@@ -0,0 +1,42 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClassifyTicketTool = exports.ClassificationResultSchema = void 0;
+const zod_1 = require("zod");
+const common_1 = require("@loopstack/common");
+const ClassifyTicketSchema = zod_1.z
+    .object({
+    text: zod_1.z.string(),
+})
+    .strict();
+exports.ClassificationResultSchema = zod_1.z.strictObject({
+    severity: zod_1.z.enum(['high', 'normal']),
+    reason: zod_1.z.string(),
+});
+const URGENCY_KEYWORDS = ['down', 'outage', 'urgent', 'critical'];
+let ClassifyTicketTool = class ClassifyTicketTool extends common_1.BaseTool {
+    async handle(args) {
+        const matched = URGENCY_KEYWORDS.find((word) => args.text.toLowerCase().includes(word));
+        return Promise.resolve({
+            data: matched
+                ? { severity: 'high', reason: `matched urgency keyword "${matched}"` }
+                : { severity: 'normal', reason: 'no urgency keywords' },
+        });
+    }
+};
+exports.ClassifyTicketTool = ClassifyTicketTool;
+exports.ClassifyTicketTool = ClassifyTicketTool = __decorate([
+    (0, common_1.Tool)({
+        name: 'classify_ticket',
+        description: 'Classifies a support ticket as high or normal severity based on urgency keywords.',
+        schema: ClassifyTicketSchema,
+        resultSchema: exports.ClassificationResultSchema,
+        effects: 'none',
+    })
+], ClassifyTicketTool);
+//# sourceMappingURL=classify-ticket.tool.js.map

package/dist/triage/classify-ticket.tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"classify-ticket.tool.js","sourceRoot":"","sources":["../../src/triage/classify-ticket.tool.ts"],"names":[],"mappings":";;;;;;;;;AAAA,6BAAwB;AACxB,8CAAiE;AAEjE,MAAM,oBAAoB,GAAG,OAAC;KAC3B,MAAM,CAAC;IACN,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;CACjB,CAAC;KACD,MAAM,EAAE,CAAC;AASC,QAAA,0BAA0B,GAAG,OAAC,CAAC,YAAY,CAAC;IACvD,QAAQ,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;IACpC,MAAM,EAAE,OAAC,CAAC,MAAM,EAAE;CACnB,CAAC,CAAC;AAEH,MAAM,gBAAgB,GAAG,CAAC,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC;AAS3D,IAAM,kBAAkB,GAAxB,MAAM,kBAAmB,SAAQ,iBAA0D;IACtF,KAAK,CAAC,MAAM,CAAC,IAAwB;QAC7C,MAAM,OAAO,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC;QACxF,OAAO,OAAO,CAAC,OAAO,CAAC;YACrB,IAAI,EAAE,OAAO;gBACX,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,4BAA4B,OAAO,GAAG,EAAE;gBACtE,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,EAAE,qBAAqB,EAAE;SAC1D,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AATY,gDAAkB;6BAAlB,kBAAkB;IAP9B,IAAA,aAAI,EAAC;QACJ,IAAI,EAAE,iBAAiB;QACvB,WAAW,EAAE,mFAAmF;QAChG,MAAM,EAAE,oBAAoB;QAC5B,YAAY,EAAE,kCAA0B;QACxC,OAAO,EAAE,MAAM;KAChB,CAAC;GACW,kBAAkB,CAS9B"}

package/dist/triage/index.d.ts

@@ -0,0 +1,4 @@
+export * from './approval-prompt.document';
+export * from './classify-ticket.tool';
+export * from './triage-ticket.workflow';
+//# sourceMappingURL=index.d.ts.map

package/dist/triage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/triage/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC"}

package/dist/triage/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./approval-prompt.document"), exports);
+__exportStar(require("./classify-ticket.tool"), exports);
+__exportStar(require("./triage-ticket.workflow"), exports);
+//# sourceMappingURL=index.js.map

package/dist/triage/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/triage/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,6DAA2C;AAC3C,yDAAuC;AACvC,2DAAyC"}

package/dist/triage/triage-ticket.workflow.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { BaseWorkflow } from '@loopstack/common';
+import type { RunContext, TransitionInput } from '@loopstack/common';
+import { ClassifyTicketTool } from './classify-ticket.tool';
+declare const TriageTicketSchema: z.ZodObject<{
+    text: z.ZodString;
+}, z.core.$strip>;
+type TriageTicketArgs = z.infer<typeof TriageTicketSchema>;
+interface TriageTicketState {
+    severity?: 'high' | 'normal';
+    reason?: string;
+}
+export declare class TriageTicketWorkflow extends BaseWorkflow<TriageTicketArgs> {
+    private readonly classifyTicket;
+    constructor(classifyTicket: ClassifyTicketTool);
+    classify(state: TriageTicketState, ctx: RunContext<TriageTicketArgs>): Promise<void>;
+    report(state: TriageTicketState): Promise<void>;
+    approve(state: TriageTicketState, input: TransitionInput<{
+        answer: 'yes' | 'no';
+    }>): void;
+}
+export {};
+//# sourceMappingURL=triage-ticket.workflow.d.ts.map

package/dist/triage/triage-ticket.workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-ticket.workflow.d.ts","sourceRoot":"","sources":["../../src/triage/triage-ticket.workflow.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,EAAwB,MAAM,mBAAmB,CAAC;AACvE,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAErE,OAAO,EAAwB,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAElF,QAAA,MAAM,kBAAkB;;iBAEtB,CAAC;AAEH,KAAK,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAE3D,UAAU,iBAAiB;IACzB,QAAQ,CAAC,EAAE,MAAM,GAAG,QAAQ,CAAC;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAID,qBAOa,oBAAqB,SAAQ,YAAY,CAAC,gBAAgB,CAAC;IAC1D,OAAO,CAAC,QAAQ,CAAC,cAAc;gBAAd,cAAc,EAAE,kBAAkB;IAKzD,QAAQ,CAAC,KAAK,EAAE,iBAAiB,EAAE,GAAG,EAAE,UAAU,CAAC,gBAAgB,CAAC;IAOpE,MAAM,CAAC,KAAK,EAAE,iBAAiB;IAYrC,OAAO,CAAC,KAAK,EAAE,iBAAiB,EAAE,KAAK,EAAE,eAAe,CAAC;QAAE,MAAM,EAAE,KAAK,GAAG,IAAI,CAAA;KAAE,CAAC;CAMnF"}

package/dist/triage/triage-ticket.workflow.js

@@ -0,0 +1,70 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriageTicketWorkflow = void 0;
+const zod_1 = require("zod");
+const common_1 = require("@loopstack/common");
+const approval_prompt_document_1 = require("./approval-prompt.document");
+const classify_ticket_tool_1 = require("./classify-ticket.tool");
+const TriageTicketSchema = zod_1.z.object({
+    text: zod_1.z.string(),
+});
+const ApprovalSchema = zod_1.z.object({ answer: zod_1.z.enum(['yes', 'no']) });
+let TriageTicketWorkflow = class TriageTicketWorkflow extends common_1.BaseWorkflow {
+    classifyTicket;
+    constructor(classifyTicket) {
+        super();
+        this.classifyTicket = classifyTicket;
+    }
+    async classify(state, ctx) {
+        const result = await this.classifyTicket.call({ text: ctx.args.text });
+        const { severity, reason } = result.data;
+        this.assignState({ severity, reason });
+    }
+    async report(state) {
+        await this.documentStore.save(approval_prompt_document_1.ApprovalPromptDocument, {
+            severity: state.severity,
+            question: `Ticket severity: ${state.severity} (${state.reason}). Approve this classification?`,
+        }, { key: 'approval_prompt' });
+    }
+    approve(state, input) {
+        this.setResult({ severity: state.severity, approved: input.data.answer === 'yes' });
+    }
+};
+exports.TriageTicketWorkflow = TriageTicketWorkflow;
+__decorate([
+    (0, common_1.Transition)({ to: 'classified' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
+], TriageTicketWorkflow.prototype, "classify", null);
+__decorate([
+    (0, common_1.Transition)({ from: 'classified', to: 'awaiting_approval' }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object]),
+    __metadata("design:returntype", Promise)
+], TriageTicketWorkflow.prototype, "report", null);
+__decorate([
+    (0, common_1.Transition)({ from: 'awaiting_approval', to: 'end', wait: true, schema: ApprovalSchema }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", void 0)
+], TriageTicketWorkflow.prototype, "approve", null);
+exports.TriageTicketWorkflow = TriageTicketWorkflow = __decorate([
+    (0, common_1.Workflow)({
+        name: 'triage_ticket',
+        title: 'Testing - Ticket Triage Example',
+        description: 'Classifies a support ticket with a tool, presents the severity as a yes/no approval prompt, and waits for the human decision — the example workflow behind the testing guide.',
+        schema: TriageTicketSchema,
+    }),
+    __metadata("design:paramtypes", [classify_ticket_tool_1.ClassifyTicketTool])
+], TriageTicketWorkflow);
+//# sourceMappingURL=triage-ticket.workflow.js.map

package/dist/triage/triage-ticket.workflow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"triage-ticket.workflow.js","sourceRoot":"","sources":["../../src/triage/triage-ticket.workflow.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,6BAAwB;AACxB,8CAAuE;AAEvE,yEAAoE;AACpE,iEAAkF;AAElF,MAAM,kBAAkB,GAAG,OAAC,CAAC,MAAM,CAAC;IAClC,IAAI,EAAE,OAAC,CAAC,MAAM,EAAE;CACjB,CAAC,CAAC;AASH,MAAM,cAAc,GAAG,OAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,OAAC,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC;AAS5D,IAAM,oBAAoB,GAA1B,MAAM,oBAAqB,SAAQ,qBAA8B;IACzC;IAA7B,YAA6B,cAAkC;QAC7D,KAAK,EAAE,CAAC;QADmB,mBAAc,GAAd,cAAc,CAAoB;IAE/D,CAAC;IAGK,AAAN,KAAK,CAAC,QAAQ,CAAC,KAAwB,EAAE,GAAiC;QACxE,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,IAAI,EAAE,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;QACvE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,IAA4B,CAAC;QACjE,IAAI,CAAC,WAAW,CAAC,EAAE,QAAQ,EAAE,MAAM,EAAE,CAAC,CAAC;IACzC,CAAC;IAGK,AAAN,KAAK,CAAC,MAAM,CAAC,KAAwB;QACnC,MAAM,IAAI,CAAC,aAAa,CAAC,IAAI,CAC3B,iDAAsB,EACtB;YACE,QAAQ,EAAE,KAAK,CAAC,QAAS;YACzB,QAAQ,EAAE,oBAAoB,KAAK,CAAC,QAAQ,KAAK,KAAK,CAAC,MAAM,iCAAiC;SAC/F,EACD,EAAE,GAAG,EAAE,iBAAiB,EAAE,CAC3B,CAAC;IACJ,CAAC;IAGD,OAAO,CAAC,KAAwB,EAAE,KAAgD;QAChF,IAAI,CAAC,SAAS,CAAC,EAAE,QAAQ,EAAE,KAAK,CAAC,QAAQ,EAAE,QAAQ,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,KAAK,KAAK,EAG/E,CAAC,CAAC;IACL,CAAC;CACF,CAAA;AA/BY,oDAAoB;AAMzB;IADL,IAAA,mBAAU,EAAC,EAAE,EAAE,EAAE,YAAY,EAAE,CAAC;;;;oDAKhC;AAGK;IADL,IAAA,mBAAU,EAAC,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,EAAE,mBAAmB,EAAE,CAAC;;;;kDAU3D;AAGD;IADC,IAAA,mBAAU,EAAC,EAAE,IAAI,EAAE,mBAAmB,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,cAAc,EAAE,CAAC;;;;mDAMxF;+BA9BU,oBAAoB;IAPhC,IAAA,iBAAQ,EAAC;QACR,IAAI,EAAE,eAAe;QACrB,KAAK,EAAE,iCAAiC;QACxC,WAAW,EACT,+KAA+K;QACjL,MAAM,EAAE,kBAAkB;KAC3B,CAAC;qCAE6C,yCAAkB;GADpD,oBAAoB,CA+BhC"}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@loopstack/testing-examples",
   "displayName": "Loopstack Testing Examples",
-  "description": "Placeholder for workflow testing examples — fixtures, assertions, mocked LLM responses (coming soon).",
+  "description": "Workflow testing examples — runWorkflow in-process tests, scripted HITL answers, tool unit tests with testTool, and record/replay fixtures.",
   "keywords": [
     "loopstack",
     "example",
     "testing",
     "workflow"
   ],
-  "version": "0.1.0",
+  "version": "0.2.0",
   "license": "MIT",
   "author": {
     "name": "Jakob Klippel",
@@ -30,13 +30,15 @@
   },
   "dependencies": {
     "@loopstack/common": "*",
-    "@nestjs/common": "^11.1.19"
+    "@nestjs/common": "^11.1.19",
+    "zod": "^4.3.6"
   },
   "files": [
     "dist",
     "src"
   ],
   "devDependencies": {
+    "@loopstack/testing": "*",
     "vitest": "^4.1.6",
     "@swc/core": "^1.15.33",
     "unplugin-swc": "^1.5.9"

package/src/index.ts

@@ -1 +1,2 @@
 export * from './testing-examples.module';
+export * from './triage';

package/src/testing-examples.module.ts

@@ -1,9 +1,13 @@
 import { Module } from '@nestjs/common';
 import { StudioApp } from '@loopstack/common';
+import { ClassifyTicketTool } from './triage/classify-ticket.tool';
+import { TriageTicketWorkflow } from './triage/triage-ticket.workflow';
 
 @StudioApp({
   title: 'Testing Examples',
-  workflows: [],
+  workflows: [TriageTicketWorkflow],
+})
+@Module({
+  providers: [TriageTicketWorkflow, ClassifyTicketTool],
 })
-@Module({})
 export class TestingExamplesModule {}

package/src/triage/__tests__/__recordings__/triage.json

@@ -0,0 +1,17 @@
+{
+  "version": 3,
+  "recordings": [
+    {
+      "tool": "classify_ticket",
+      "workflow": "triage_ticket",
+      "transition": "classify",
+      "args": { "text": "Production is down!" },
+      "envelope": {
+        "data": {
+          "severity": "high",
+          "reason": "replayed from recording"
+        }
+      }
+    }
+  ]
+}

package/src/triage/__tests__/classify-ticket.tool.spec.ts

@@ -0,0 +1,36 @@
+import type { TestingModule } from '@nestjs/testing';
+import { afterEach, describe, expect, it } from 'vitest';
+import { testTool } from '@loopstack/testing';
+import { ClassifyTicketTool } from '../classify-ticket.tool';
+
+/**
+ * Tool unit test: the smallest testable unit — given args, assert on the returned envelope
+ * data. `call()` runs the tool through the real pipeline, so the declared `resultSchema` is
+ * validated on the way out.
+ *
+ * Acceptance criteria:
+ *   C1 — urgency keywords grade a ticket as high severity, naming the matched keyword.
+ *   C2 — a routine ticket grades as normal severity.
+ */
+describe('ClassifyTicketTool', () => {
+  let module: TestingModule;
+  afterEach(() => module?.close());
+
+  it('C1: grades an outage as high severity', async () => {
+    module = await testTool().forTool(ClassifyTicketTool).compile();
+    const tool = module.get(ClassifyTicketTool);
+
+    const result = await tool.call({ text: 'Production is down!' });
+
+    expect(result.data).toMatchObject({ severity: 'high', reason: 'matched urgency keyword "down"' });
+  });
+
+  it('C2: grades a routine question as normal severity', async () => {
+    module = await testTool().forTool(ClassifyTicketTool).compile();
+    const tool = module.get(ClassifyTicketTool);
+
+    const result = await tool.call({ text: 'How do I change my invoice address?' });
+
+    expect(result.data).toMatchObject({ severity: 'normal', reason: 'no urgency keywords' });
+  });
+});

package/src/triage/__tests__/triage-ticket-contract-fake.spec.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from 'vitest';
+import { createContractFake, runWorkflow } from '@loopstack/testing';
+import { ClassifyTicketTool } from '../classify-ticket.tool';
+import { TriageTicketWorkflow } from '../triage-ticket.workflow';
+
+/**
+ * Contract fake: a DI-level tool replacement whose scripted response is validated against
+ * the tool's declared `resultSchema` at scripting time. Use it when you want to control a
+ * tool's output *and* assert how the workflow called it (`fake.call` is a vitest mock) —
+ * the contract-honest alternative to a free-form mock and the lighter-weight cousin of a
+ * recorded fixture. A scripted envelope that drifts from the tool's real result shape fails
+ * the test instead of passing against a stale mock.
+ */
+describe('TriageTicketWorkflow — contract fake', () => {
+  it('drives the workflow with a scripted classification and asserts the call', async () => {
+    const classify = createContractFake(ClassifyTicketTool);
+    classify.returns({ data: { severity: 'high', reason: 'scripted by the contract fake' } });
+
+    const run = await runWorkflow(
+      TriageTicketWorkflow,
+      { text: 'Production is down!' },
+      {
+        // Substitute the tool with the fake. (For a tool that comes from an imported module,
+        // reach it with `overrides: [[Tool, fake]]` instead.)
+        providers: [{ provide: ClassifyTicketTool, useValue: classify }],
+        answers: { approve: { answer: 'yes' } },
+      },
+    );
+
+    expect(run.status).toBe('completed');
+    expect(run.result).toMatchObject({ severity: 'high', approved: true });
+    // The workflow passed the ticket text straight through to the tool.
+    expect(classify.call).toHaveBeenCalledWith({ text: 'Production is down!' });
+    expect(run.document('approval_prompt')).toMatchObject({
+      question: expect.stringContaining('scripted by the contract fake'),
+    });
+  });
+});

package/src/triage/__tests__/triage-ticket-replay.spec.ts

@@ -0,0 +1,62 @@
+import { join } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import { replay, runWorkflow } from '@loopstack/testing';
+import { ClassifyTicketTool } from '../classify-ticket.tool';
+import { TriageTicketWorkflow } from '../triage-ticket.workflow';
+
+/**
+ * Record/replay: recorded tool responses are returned instead of executing the tool — the
+ * workflow's own code still runs for real. Replaying makes non-deterministic tools (above
+ * all LLM calls) deterministic; here the classifier is deterministic already, so the point
+ * is the mechanism itself.
+ *
+ * The `fixture:` option is the default path — it replays when the file exists and records a
+ * fresh fixture when it is missing (in CI a missing fixture is an error, so a forgotten
+ * `git add` can never silently downgrade the test into a live run). Record a fixture from a
+ * real run:
+ *
+ *   loopstack run triage_ticket --arg text="Production is down!" --trace
+ *   loopstack runs <run-id> --record src/triage/__tests__/__recordings__/triage.json
+ */
+describe('TriageTicketWorkflow — record/replay', () => {
+  it('replays the committed fixture instead of executing the tool', async () => {
+    const run = await runWorkflow(
+      TriageTicketWorkflow,
+      { text: 'Production is down!' },
+      {
+        providers: [ClassifyTicketTool],
+        answers: { approve: { answer: 'yes' } },
+        fixture: join(__dirname, '__recordings__/triage.json'),
+      },
+    );
+
+    expect(run.status).toBe('completed');
+    // The reason text can only come from the fixture — proof the live tool never ran.
+    expect(run.result).toMatchObject({ severity: 'high', approved: true });
+    expect(run.document('approval_prompt')).toMatchObject({
+      question: expect.stringContaining('replayed from recording'),
+    });
+  });
+
+  it('accepts an inline fixture for fully-scripted determinism', async () => {
+    const run = await runWorkflow(
+      TriageTicketWorkflow,
+      { text: 'anything at all' },
+      {
+        providers: [ClassifyTicketTool],
+        answers: { approve: { answer: 'yes' } },
+        replay: replay({
+          version: 3,
+          recordings: [
+            {
+              tool: 'classify_ticket',
+              envelope: { data: { severity: 'normal', reason: 'inline fixture' } },
+            },
+          ],
+        }),
+      },
+    );
+
+    expect(run.result).toMatchObject({ severity: 'normal', approved: true });
+  });
+});

package/src/triage/__tests__/triage-ticket.workflow.spec.ts

@@ -0,0 +1,80 @@
+import { describe, expect, it } from 'vitest';
+import { type TestRun, coverage, runWorkflow } from '@loopstack/testing';
+import { TestingExamplesModule } from '../../testing-examples.module';
+import { ClassifyTicketTool } from '../classify-ticket.tool';
+import { TriageTicketWorkflow } from '../triage-ticket.workflow';
+
+/**
+ * Workflow tests: the real state machine runs in-process — no backend, no database.
+ * Each scenario is named for the acceptance criterion it checks (`C1:`…), so the test
+ * report reads as a criteria matrix (see the Testing Methodology guide). Assert on
+ * outcomes — status, path, result, documents, and what the user sees at a park — never
+ * on internal mechanics.
+ *
+ * Acceptance criteria:
+ *   C1 — a high-severity ticket is classified, reported, and (on approval) completes as approved.
+ *   C2 — while awaiting approval the run parks showing a yes/no prompt with the severity.
+ *   C3 — a rejected classification completes as not approved.
+ */
+describe('TriageTicketWorkflow', () => {
+  const runs: TestRun[] = [];
+  const run = async (text: string, answer?: 'yes' | 'no') => {
+    const result = await runWorkflow(
+      TriageTicketWorkflow,
+      { text },
+      {
+        // Import the app module so the document's widget config is discoverable —
+        // parkView() resolves the same widget the CLI and Studio render.
+        imports: [TestingExamplesModule],
+        providers: [ClassifyTicketTool],
+        ...(answer ? { answers: { approve: { answer } } } : {}),
+      },
+    );
+    runs.push(result);
+    return result;
+  };
+
+  it('C1: classifies an outage as high severity and completes when approved', async () => {
+    const result = await run('Production is down!', 'yes');
+
+    expect(result.status).toBe('completed');
+    expect(result.path).toEqual(['classify', 'report', 'approve']);
+    expect(result.result).toMatchObject({ severity: 'high', approved: true });
+    expect(result.document('approval_prompt')).toMatchObject({
+      severity: 'high',
+      question: 'Ticket severity: high (matched urgency keyword "down"). Approve this classification?',
+    });
+  });
+
+  it('C2: parks for approval showing the severity prompt', async () => {
+    const result = await run('Where is my invoice?');
+
+    expect(result.status).toBe('waiting');
+    expect(result.place).toBe('awaiting_approval');
+    expect(result.path).toEqual(['classify', 'report']);
+
+    // What the human would see at this park — resolved by the same rules the CLI and Studio use.
+    const view = result.parkView();
+    expect(view).toMatchObject({
+      widget: 'confirm-prompt',
+      documentName: 'approval_prompt',
+      content: { severity: 'normal', question: expect.stringContaining('normal') },
+      transitions: ['approve'],
+      defaultTransition: 'approve',
+    });
+  });
+
+  it('C3: records a rejected classification', async () => {
+    const result = await run('Urgent: cannot log in', 'no');
+
+    expect(result.status).toBe('completed');
+    expect(result.result).toMatchObject({ severity: 'high', approved: false });
+  });
+
+  it('covers every declared transition and park (coverage gate)', () => {
+    const cov = coverage(runs, TriageTicketWorkflow);
+    expect(cov.missingTransitions).toEqual([]);
+    expect(cov.missingParks).toEqual([]);
+    expect(cov.complete).toBe(true);
+  });
+});

package/src/triage/approval-prompt.document.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { Document } from '@loopstack/common';
+
+export const ApprovalPromptSchema = z
+  .object({
+    question: z.string(),
+    severity: z.enum(['high', 'normal']),
+    answer: z.string().optional(),
+  })
+  .strict();
+
+export type ApprovalPromptType = z.infer<typeof ApprovalPromptSchema>;
+
+/**
+ * The human touchpoint of the triage flow: a yes/no approval prompt shown while the
+ * workflow waits. The inline `confirm-prompt` widget binds the "Yes"/"No" answer to the
+ * `approve` wait transition — the same widget the CLI and Studio render, so a test can
+ * assert `parkView()` (widget, question, default transition) exactly as a user would see it.
+ */
+@Document({
+  schema: ApprovalPromptSchema,
+  widget: { widget: 'confirm-prompt', options: { transition: 'approve' } },
+})
+export class ApprovalPromptDocument {
+  question: string;
+  severity: 'high' | 'normal';
+  answer?: string;
+}

package/src/triage/classify-ticket.tool.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+import { BaseTool, Tool, ToolEnvelope } from '@loopstack/common';
+
+const ClassifyTicketSchema = z
+  .object({
+    text: z.string(),
+  })
+  .strict();
+
+type ClassifyTicketArgs = z.infer<typeof ClassifyTicketSchema>;
+
+export interface ClassificationResult {
+  severity: 'high' | 'normal';
+  reason: string;
+}
+
+export const ClassificationResultSchema = z.strictObject({
+  severity: z.enum(['high', 'normal']),
+  reason: z.string(),
+});
+
+const URGENCY_KEYWORDS = ['down', 'outage', 'urgent', 'critical'];
+
+@Tool({
+  name: 'classify_ticket',
+  description: 'Classifies a support ticket as high or normal severity based on urgency keywords.',
+  schema: ClassifyTicketSchema,
+  resultSchema: ClassificationResultSchema,
+  effects: 'none',
+})
+export class ClassifyTicketTool extends BaseTool<ClassifyTicketArgs, object, ClassificationResult> {
+  protected async handle(args: ClassifyTicketArgs): Promise<ToolEnvelope<ClassificationResult>> {
+    const matched = URGENCY_KEYWORDS.find((word) => args.text.toLowerCase().includes(word));
+    return Promise.resolve({
+      data: matched
+        ? { severity: 'high', reason: `matched urgency keyword "${matched}"` }
+        : { severity: 'normal', reason: 'no urgency keywords' },
+    });
+  }
+}

package/src/triage/index.ts

@@ -0,0 +1,3 @@
+export * from './approval-prompt.document';
+export * from './classify-ticket.tool';
+export * from './triage-ticket.workflow';

package/src/triage/triage-ticket.workflow.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+import { BaseWorkflow, Transition, Workflow } from '@loopstack/common';
+import type { RunContext, TransitionInput } from '@loopstack/common';
+import { ApprovalPromptDocument } from './approval-prompt.document';
+import { ClassificationResult, ClassifyTicketTool } from './classify-ticket.tool';
+
+const TriageTicketSchema = z.object({
+  text: z.string(),
+});
+
+type TriageTicketArgs = z.infer<typeof TriageTicketSchema>;
+
+interface TriageTicketState {
+  severity?: 'high' | 'normal';
+  reason?: string;
+}
+
+const ApprovalSchema = z.object({ answer: z.enum(['yes', 'no']) });
+
+@Workflow({
+  name: 'triage_ticket',
+  title: 'Testing - Ticket Triage Example',
+  description:
+    'Classifies a support ticket with a tool, presents the severity as a yes/no approval prompt, and waits for the human decision — the example workflow behind the testing guide.',
+  schema: TriageTicketSchema,
+})
+export class TriageTicketWorkflow extends BaseWorkflow<TriageTicketArgs> {
+  constructor(private readonly classifyTicket: ClassifyTicketTool) {
+    super();
+  }
+
+  @Transition({ to: 'classified' })
+  async classify(state: TriageTicketState, ctx: RunContext<TriageTicketArgs>) {
+    const result = await this.classifyTicket.call({ text: ctx.args.text });
+    const { severity, reason } = result.data as ClassificationResult;
+    this.assignState({ severity, reason });
+  }
+
+  @Transition({ from: 'classified', to: 'awaiting_approval' })
+  async report(state: TriageTicketState) {
+    await this.documentStore.save(
+      ApprovalPromptDocument,
+      {
+        severity: state.severity!,
+        question: `Ticket severity: ${state.severity} (${state.reason}). Approve this classification?`,
+      },
+      { key: 'approval_prompt' },
+    );
+  }
+
+  @Transition({ from: 'awaiting_approval', to: 'end', wait: true, schema: ApprovalSchema })
+  approve(state: TriageTicketState, input: TransitionInput<{ answer: 'yes' | 'no' }>) {
+    this.setResult({ severity: state.severity, approved: input.data.answer === 'yes' } as unknown as Record<
+      string,
+      unknown
+    >);
+  }
+}