@open-mercato/core 0.7.1-develop.7193.1.910a5b0a1e → 0.7.1-develop.7195.1.b5efd1d51a

package/dist/modules/workflows/ai-agents.js

@@ -0,0 +1,50 @@
+import {
+  WORKFLOW_DRAFT_AGENT_ID,
+  workflowDraftGenerationSchema
+} from "./lib/ai-authoring.js";
+const SYSTEM_PROMPT = [
+  "ROLE: You author Open Mercato workflow definitions from a plain-language request.",
+  "",
+  "SCOPE: You produce a DRAFT for a human to review in the workflow Studio. You never publish, enable or execute anything. Your only tool is workflows.validate_workflow_definition, a read-only validator; the request carries every identifier you are allowed to use.",
+  "",
+  "SELF-CHECK: Before you return, call workflows.validate_workflow_definition with your draft and fix every reported error. Re-validate until it reports no errors.",
+  "",
+  "DATA: The request contains a catalog of the step types, transition triggers, activity types (with their JSON-Schema config contracts), safe command ids, registered function names and declared event ids this installation actually has. Any identifier outside that catalog does not exist. If the request cannot be satisfied with the catalog, author the closest workflow you can and describe the gap in `summary`.",
+  "",
+  "STRUCTURE: Exactly one START step and at least one END step. Every step except END has an outgoing transition; every step except START is reachable from START. Ids use lowercase letters, numbers, hyphens and underscores only. Activities run on the transition LEAVING the step whose work they perform.",
+  "",
+  "CONTEXT: Reference run data as {{context.<path>}} and declare every referenced path in contextSchema.input.fields. Do not invent context paths no trigger or earlier step could produce.",
+  "",
+  "RESPONSE STYLE: Emit only the structured object. `summary` is one plain sentence an operator can read; it is not a restatement of the JSON."
+].join("\n");
+const workflowAuthorAgent = {
+  id: WORKFLOW_DRAFT_AGENT_ID,
+  moduleId: "workflows",
+  label: "Workflow author",
+  description: "Turns a plain-language request into a draft workflow definition, authored against this installation's real activity, command, function and event catalogs. Proposes only \u2014 never publishes.",
+  systemPrompt: SYSTEM_PROMPT,
+  allowedTools: ["workflows.validate_workflow_definition"],
+  executionMode: "object",
+  readOnly: true,
+  mutationPolicy: "read-only",
+  requiredFeatures: ["workflows.definitions.create"],
+  // A validate loop needs only a couple of round-trips; keep it tight so a
+  // model that never converges cannot burn tokens or wall-clock unbounded.
+  loop: {
+    budget: { maxToolCalls: 4, maxWallClockMs: 2e4, maxTokens: 12e4 }
+  },
+  output: {
+    schemaName: "WorkflowDraft",
+    schema: workflowDraftGenerationSchema,
+    mode: "generate"
+  },
+  keywords: ["workflow", "process", "automation", "draft", "authoring"],
+  domain: "workflows"
+};
+const aiAgents = [workflowAuthorAgent];
+var ai_agents_default = aiAgents;
+export {
+  aiAgents,
+  ai_agents_default as default
+};
+//# sourceMappingURL=ai-agents.js.map

package/dist/modules/workflows/ai-agents.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/modules/workflows/ai-agents.ts"],
+  "sourcesContent": ["/**\n * Module-root AI agent contribution for the workflows module (spec \u00A79,\n * \"prompt-to-draft\").\n *\n * ONE agent, and its shape IS the trust boundary:\n *\n *  - `executionMode: 'object'` \u2014 it emits a structured draft against\n *    `workflowDraftGenerationSchema`, not prose. Generation targets schemas.\n *    Its one tool runs inside the runtime's object-mode tool loop\n *    (`runAiAgentObject({ enableTools: true })`), which still finalizes through\n *    `Output.object`, so the emitted result stays a validated draft.\n *  - `allowedTools: ['workflows.validate_workflow_definition']` \u2014 exactly ONE\n *    READ-ONLY tool. It reads no tenant rows and writes nothing; it re-runs the\n *    real definition schema + Problems pass so the agent can self-correct a\n *    draft (e.g. a partial INVOKE_AGENT config) before returning. This is a\n *    deliberate, bounded relaxation of the former empty allowlist \u2014 the broader\n *    `workflows.*` authoring/write tools (create/update/test-run) remain out of\n *    reach; this in-Studio path reaches only the validator.\n *  - `readOnly: true` + `mutationPolicy: 'read-only'` \u2014 belt and braces, so a\n *    later tool addition cannot quietly become write-capable (the runtime\n *    strips any `isMutation` tool from a read-only agent).\n *\n * The route that calls it (`api/definitions/generate`) persists NOTHING. A\n * generated definition becomes real only after a human applies it to the canvas\n * AND saves AND enables it \u2014 three separate deliberate acts.\n *\n * Requires `yarn generate` to be discovered; until then the runtime answers\n * `agent_unknown` and the Studio reports that AI authoring is unavailable.\n */\nimport type { AiAgentDefinition } from '@open-mercato/ai-assistant/modules/ai_assistant/lib/ai-agent-definition'\nimport {\n  WORKFLOW_DRAFT_AGENT_ID,\n  workflowDraftGenerationSchema,\n} from './lib/ai-authoring'\n\nconst SYSTEM_PROMPT = [\n  'ROLE: You author Open Mercato workflow definitions from a plain-language request.',\n  '',\n  'SCOPE: You produce a DRAFT for a human to review in the workflow Studio. You never publish, enable or execute anything. Your only tool is workflows.validate_workflow_definition, a read-only validator; the request carries every identifier you are allowed to use.',\n  '',\n  'SELF-CHECK: Before you return, call workflows.validate_workflow_definition with your draft and fix every reported error. Re-validate until it reports no errors.',\n  '',\n  'DATA: The request contains a catalog of the step types, transition triggers, activity types (with their JSON-Schema config contracts), safe command ids, registered function names and declared event ids this installation actually has. Any identifier outside that catalog does not exist. If the request cannot be satisfied with the catalog, author the closest workflow you can and describe the gap in `summary`.',\n  '',\n  'STRUCTURE: Exactly one START step and at least one END step. Every step except END has an outgoing transition; every step except START is reachable from START. Ids use lowercase letters, numbers, hyphens and underscores only. Activities run on the transition LEAVING the step whose work they perform.',\n  '',\n  'CONTEXT: Reference run data as {{context.<path>}} and declare every referenced path in contextSchema.input.fields. Do not invent context paths no trigger or earlier step could produce.',\n  '',\n  'RESPONSE STYLE: Emit only the structured object. `summary` is one plain sentence an operator can read; it is not a restatement of the JSON.',\n].join('\\n')\n\nconst workflowAuthorAgent: AiAgentDefinition = {\n  id: WORKFLOW_DRAFT_AGENT_ID,\n  moduleId: 'workflows',\n  label: 'Workflow author',\n  description:\n    'Turns a plain-language request into a draft workflow definition, authored against this installation\\'s real activity, command, function and event catalogs. Proposes only \u2014 never publishes.',\n  systemPrompt: SYSTEM_PROMPT,\n  allowedTools: ['workflows.validate_workflow_definition'],\n  executionMode: 'object',\n  readOnly: true,\n  mutationPolicy: 'read-only',\n  requiredFeatures: ['workflows.definitions.create'],\n  // A validate loop needs only a couple of round-trips; keep it tight so a\n  // model that never converges cannot burn tokens or wall-clock unbounded.\n  loop: {\n    budget: { maxToolCalls: 4, maxWallClockMs: 20_000, maxTokens: 120_000 },\n  },\n  output: {\n    schemaName: 'WorkflowDraft',\n    schema: workflowDraftGenerationSchema,\n    mode: 'generate',\n  },\n  keywords: ['workflow', 'process', 'automation', 'draft', 'authoring'],\n  domain: 'workflows',\n}\n\nexport const aiAgents: AiAgentDefinition[] = [workflowAuthorAgent]\n\nexport default aiAgents\n"],
+  "mappings": "AA8BA;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,MAAM,gBAAgB;AAAA,EACpB;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,EAAE,KAAK,IAAI;AAEX,MAAM,sBAAyC;AAAA,EAC7C,IAAI;AAAA,EACJ,UAAU;AAAA,EACV,OAAO;AAAA,EACP,aACE;AAAA,EACF,cAAc;AAAA,EACd,cAAc,CAAC,wCAAwC;AAAA,EACvD,eAAe;AAAA,EACf,UAAU;AAAA,EACV,gBAAgB;AAAA,EAChB,kBAAkB,CAAC,8BAA8B;AAAA;AAAA;AAAA,EAGjD,MAAM;AAAA,IACJ,QAAQ,EAAE,cAAc,GAAG,gBAAgB,KAAQ,WAAW,KAAQ;AAAA,EACxE;AAAA,EACA,QAAQ;AAAA,IACN,YAAY;AAAA,IACZ,QAAQ;AAAA,IACR,MAAM;AAAA,EACR;AAAA,EACA,UAAU,CAAC,YAAY,WAAW,cAAc,SAAS,WAAW;AAAA,EACpE,QAAQ;AACV;AAEO,MAAM,WAAgC,CAAC,mBAAmB;AAEjE,IAAO,oBAAQ;",
+  "names": []
+}

package/dist/modules/workflows/ai-tools/authoring-pack.js

@@ -0,0 +1,582 @@
+import { z } from "zod";
+import { zodToJsonSchema } from "@open-mercato/shared/lib/openapi";
+import {
+  WorkflowDefinition,
+  WorkflowDefinitionDraft,
+  WorkflowEvent,
+  WorkflowInstance,
+  StepInstance
+} from "../data/entities.js";
+import {
+  createWorkflowDefinitionInputCheckedSchema,
+  workflowDefinitionDataSchema
+} from "../data/validators.js";
+import { workflowDraftGenerationSchema } from "../lib/ai-authoring.js";
+import { isComponentKind } from "../lib/component-guard.js";
+import {
+  computeDefinitionContextLedger,
+  narrowLedgerToStep,
+  resolveDefinitionDataForLedger,
+  warmContextLedgerResolvers
+} from "../lib/definition-context-schema.js";
+import { evaluateWorkflowDefinition } from "../lib/definition-evaluation.js";
+import { normalizeDefinitionValidationIssues } from "../lib/definition-error-body.js";
+import {
+  DRY_RUN_EVENT_TYPES,
+  buildWouldDoReport
+} from "../lib/dry-run.js";
+import { findWorkflowDefinition } from "../lib/find-definition.js";
+import { listActivityTypes } from "../lib/activity-registry.js";
+import "../lib/activity-registry-bootstrap.js";
+import { invalidateTriggerCache } from "../lib/event-trigger-service.js";
+import {
+  MISSING_TENANT_ISSUE,
+  failure,
+  featureRefusal,
+  issue,
+  missingFeatures,
+  organizationWhere,
+  resolveScope
+} from "./types.js";
+const DEFINITIONS_VIEW = "workflows.definitions.view";
+const DEFINITIONS_CREATE = "workflows.definitions.create";
+const DEFINITIONS_EDIT = "workflows.definitions.edit";
+const DEFINITIONS_TEST_RUN = "workflows.definitions.test_run";
+const INSTANCES_VIEW = "workflows.instances.view";
+const INSTANCES_CREATE = "workflows.instances.create";
+function resolveEm(ctx) {
+  return ctx.container.resolve("em");
+}
+const definitionIdSchema = z.string().min(1).describe('Definition UUID, or "code:<workflowId>" for a code-defined workflow');
+const rawDefinitionSchema = z.record(z.string(), z.unknown()).describe("The workflow definition JSON \u2014 the same object the Studio Code view round-trips");
+function asDefinitionData(value) {
+  return value;
+}
+async function tryComputeLedger(ctx, definition) {
+  try {
+    await warmContextLedgerResolvers(ctx.container);
+    return computeDefinitionContextLedger(definition);
+  } catch {
+    return null;
+  }
+}
+const listActivityTypesInput = z.object({
+  activityType: z.string().optional().describe("Return only this activity type instead of the whole registry")
+});
+const listActivityTypesTool = {
+  name: "workflows.list_activity_types",
+  displayName: "List workflow activity types",
+  description: "List every registered workflow activity type with its JSON-Schema config contract, form fields, async capability, compensability and dry-run mock mode. This registry IS the authoring contract \u2014 read it before writing any activity config so the config validates on the first attempt.",
+  inputSchema: listActivityTypesInput,
+  requiredFeatures: [DEFINITIONS_VIEW],
+  tags: ["read", "workflows", "authoring"],
+  isMutation: false,
+  handler: async (input, ctx) => {
+    const missing = missingFeatures(ctx, [DEFINITIONS_VIEW]);
+    if (missing.length) return featureRefusal(missing);
+    const entries = listActivityTypes().filter(
+      (entry) => !input.activityType || entry.id === input.activityType
+    );
+    if (input.activityType && entries.length === 0) {
+      return failure(
+        issue(
+          ["activityType"],
+          "unknown_activity_type",
+          `Unknown activity type "${input.activityType}"`,
+          { expected: listActivityTypes().map((entry) => entry.id).join(" | "), got: input.activityType }
+        )
+      );
+    }
+    return {
+      ok: true,
+      issues: [],
+      activityTypes: entries.map((entry) => ({
+        id: entry.id,
+        icon: entry.icon,
+        i18nKey: entry.i18nKey,
+        configSchema: zodToJsonSchema(entry.configSchema) ?? null,
+        form: entry.form.map((field) => ({
+          id: field.id,
+          component: field.component,
+          required: field.required ?? false
+        })),
+        async: entry.async,
+        compensable: entry.compensable ?? false,
+        // 'refuse' and 'none' both stop a dry run at this activity.
+        dryRunMock: entry.mock === "refuse" ? "refuse" : entry.mock === void 0 ? "none" : "simulated"
+      }))
+    };
+  }
+};
+const getContextSchemaInput = z.object({
+  definitionId: definitionIdSchema,
+  stepId: z.string().optional().describe("Narrow the response to one step instead of returning every step")
+});
+const getContextSchemaTool = {
+  name: "workflows.get_context_schema",
+  displayName: "Get workflow context ledger",
+  description: "Return the per-step context ledger for a saved workflow definition: for every step, which context paths are available when it runs, with type, presence (always/maybe) and the producing source. Use this to discover the exact {{context.*}} paths a step may reference before writing any expression.",
+  inputSchema: getContextSchemaInput,
+  requiredFeatures: [DEFINITIONS_VIEW],
+  tags: ["read", "workflows", "authoring"],
+  isMutation: false,
+  handler: async (input, ctx) => {
+    const missing = missingFeatures(ctx, [DEFINITIONS_VIEW]);
+    if (missing.length) return featureRefusal(missing);
+    const scope = resolveScope(ctx);
+    if (!scope) return failure(MISSING_TENANT_ISSUE);
+    await warmContextLedgerResolvers(ctx.container);
+    const definitionData = await resolveDefinitionDataForLedger(
+      resolveEm(ctx),
+      input.definitionId,
+      { tenantId: scope.tenantId, organizationWhere: organizationWhere(scope) }
+    );
+    if (!definitionData) {
+      return failure(
+        issue(
+          ["definitionId"],
+          "not_found",
+          "Workflow definition not found",
+          { got: input.definitionId }
+        )
+      );
+    }
+    const ledger = computeDefinitionContextLedger(definitionData);
+    if (input.stepId === void 0) {
+      return { ok: true, issues: [], steps: ledger.steps };
+    }
+    const stepView = narrowLedgerToStep(ledger, input.stepId);
+    if (!stepView) {
+      return failure(
+        issue(
+          ["stepId"],
+          "not_found",
+          "Step not found in workflow definition",
+          { got: input.stepId }
+        )
+      );
+    }
+    return { ok: true, issues: [], steps: { [input.stepId]: stepView } };
+  }
+};
+const validateDefinitionInput = z.object({
+  definition: rawDefinitionSchema.optional().describe("Validate this definition JSON directly, without saving anything"),
+  definitionId: definitionIdSchema.optional().describe("Validate the definition stored under this id instead")
+}).describe("Supply exactly one of `definition` or `definitionId`");
+const validateDefinitionTool = {
+  name: "workflows.validate_definition",
+  displayName: "Validate a workflow definition",
+  description: "Run the full workflow validation pass over a definition without saving it. Returns `issues` (the same structured {path, code, message, expected, got} list the definition API returns on a 400) and `problems` (exactly what the Studio Problems panel would show, errors first). Call this before create_definition or update_definition and fix every error.",
+  inputSchema: validateDefinitionInput,
+  requiredFeatures: [DEFINITIONS_VIEW],
+  tags: ["read", "workflows", "authoring"],
+  isMutation: false,
+  handler: async (input, ctx) => {
+    const missing = missingFeatures(ctx, [DEFINITIONS_VIEW]);
+    if (missing.length) return featureRefusal(missing);
+    if (input.definition && input.definitionId || !input.definition && !input.definitionId) {
+      return failure(
+        issue(
+          ["definition"],
+          "invalid_input",
+          "Supply exactly one of `definition` or `definitionId`",
+          { expected: "definition | definitionId" }
+        )
+      );
+    }
+    let definitionData;
+    if (input.definitionId) {
+      const scope = resolveScope(ctx);
+      if (!scope) return failure(MISSING_TENANT_ISSUE);
+      const resolved = await resolveDefinitionDataForLedger(
+        resolveEm(ctx),
+        input.definitionId,
+        { tenantId: scope.tenantId, organizationWhere: organizationWhere(scope) }
+      );
+      if (!resolved) {
+        return failure(
+          issue(["definitionId"], "not_found", "Workflow definition not found", {
+            got: input.definitionId
+          })
+        );
+      }
+      definitionData = resolved;
+    } else {
+      definitionData = asDefinitionData(input.definition);
+    }
+    const ledger = await tryComputeLedger(ctx, definitionData);
+    const evaluation = evaluateWorkflowDefinition(definitionData, { ledger });
+    return {
+      ok: evaluation.valid,
+      issues: evaluation.issues,
+      problems: evaluation.problems,
+      valid: evaluation.valid,
+      errorCount: evaluation.errorCount,
+      warningCount: evaluation.warningCount
+    };
+  }
+};
+const createDefinitionInput = z.object({
+  workflowId: z.string().min(1).max(100).describe("Stable machine id, lowercase letters/numbers/dots/hyphens/underscores"),
+  workflowName: z.string().min(1).max(255),
+  description: z.string().max(2e3).optional().nullable(),
+  definition: rawDefinitionSchema,
+  metadata: z.record(z.string(), z.unknown()).optional().nullable()
+});
+const createDefinitionTool = {
+  name: "workflows.create_definition",
+  displayName: "Create a workflow definition (disabled draft)",
+  description: "Create a new workflow definition. It is ALWAYS created disabled: it appears in the Studio for a human to review and enable, and the engine will not resolve it for execution or fire its triggers until a person publishes it. Validate with validate_definition first \u2014 this tool applies the identical schema gate the REST API applies and returns the same structured issues on rejection.",
+  inputSchema: createDefinitionInput,
+  requiredFeatures: [DEFINITIONS_CREATE],
+  tags: ["write", "workflows", "authoring"],
+  isMutation: true,
+  handler: async (input, ctx) => {
+    const missing = missingFeatures(ctx, [DEFINITIONS_CREATE]);
+    if (missing.length) return featureRefusal(missing);
+    const scope = resolveScope(ctx);
+    if (!scope) return failure(MISSING_TENANT_ISSUE);
+    if (!scope.organizationId) {
+      return failure(
+        issue(
+          ["organizationId"],
+          "missing_organization_context",
+          "An organization context is required to create a workflow definition"
+        )
+      );
+    }
+    const validation = createWorkflowDefinitionInputCheckedSchema.safeParse({
+      workflowId: input.workflowId,
+      workflowName: input.workflowName,
+      description: input.description,
+      definition: input.definition,
+      metadata: input.metadata
+    });
+    if (!validation.success) {
+      return failure(...normalizeDefinitionValidationIssues(validation.error));
+    }
+    const em = resolveEm(ctx);
+    const existing = await em.findOne(
+      WorkflowDefinition,
+      { workflowId: input.workflowId, tenantId: scope.tenantId },
+      { orderBy: { version: "DESC" } }
+    );
+    if (existing) {
+      return failure(
+        issue(
+          ["workflowId"],
+          "already_exists",
+          `Workflow definition with ID "${input.workflowId}" already exists`,
+          { got: input.workflowId }
+        )
+      );
+    }
+    const definitionData = validation.data.definition.interpolation ? validation.data.definition : { ...validation.data.definition, interpolation: "strict" };
+    const created = em.create(WorkflowDefinition, {
+      workflowId: validation.data.workflowId,
+      workflowName: validation.data.workflowName,
+      description: validation.data.description,
+      version: validation.data.version,
+      definition: definitionData,
+      metadata: validation.data.metadata,
+      // NEVER auto-published (spec §9.5). `findWorkflowDefinition` requires
+      // `enabled = true` to resolve a workflow for execution, so a human
+      // enabling it in the Studio is the only way this ever runs.
+      enabled: false,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId,
+      createdBy: ctx.userId ?? null,
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date()
+    });
+    await em.persist(created).flush();
+    invalidateTriggerCache(scope.tenantId, scope.organizationId ?? void 0);
+    const ledger = await tryComputeLedger(ctx, definitionData);
+    const evaluation = evaluateWorkflowDefinition(definitionData, {
+      ledger
+    });
+    return {
+      ok: true,
+      issues: [],
+      definitionId: created.id,
+      workflowId: created.workflowId,
+      version: created.version,
+      enabled: false,
+      published: false,
+      problems: evaluation.problems,
+      errorCount: evaluation.errorCount,
+      warningCount: evaluation.warningCount
+    };
+  }
+};
+const updateDefinitionInput = z.object({
+  definitionId: z.uuid().describe("UUID of the saved definition to draft changes against"),
+  definition: rawDefinitionSchema,
+  metadata: z.record(z.string(), z.unknown()).optional().nullable()
+});
+const updateDefinitionTool = {
+  name: "workflows.update_definition",
+  displayName: "Update a workflow definition (as a review draft)",
+  description: "Write proposed changes to a saved workflow definition as a per-user editor DRAFT. The published definition is never modified: the next person to open that definition in the Studio sees the draft offered for restore, reviews the visual and JSON diff, and decides whether to save it. Returns the Problems-panel result for the drafted definition so you can self-correct before a human looks.",
+  inputSchema: updateDefinitionInput,
+  requiredFeatures: [DEFINITIONS_EDIT],
+  tags: ["write", "workflows", "authoring"],
+  isMutation: true,
+  handler: async (input, ctx) => {
+    const missing = missingFeatures(ctx, [DEFINITIONS_EDIT]);
+    if (missing.length) return featureRefusal(missing);
+    const scope = resolveScope(ctx);
+    if (!scope) return failure(MISSING_TENANT_ISSUE);
+    if (!ctx.userId) {
+      return failure(
+        issue(
+          ["userId"],
+          "missing_user_context",
+          "A user context is required: drafts are per-user review copies"
+        )
+      );
+    }
+    const parsed = workflowDefinitionDataSchema.safeParse(input.definition);
+    if (!parsed.success) {
+      return failure(...normalizeDefinitionValidationIssues(parsed.error));
+    }
+    const em = resolveEm(ctx);
+    const definition = await em.findOne(WorkflowDefinition, {
+      id: input.definitionId,
+      tenantId: scope.tenantId,
+      ...organizationWhere(scope),
+      deletedAt: null
+    });
+    if (!definition) {
+      return failure(
+        issue(["definitionId"], "not_found", "Workflow definition not found", {
+          got: input.definitionId
+        })
+      );
+    }
+    const existingDraft = await em.findOne(WorkflowDefinitionDraft, {
+      definitionId: input.definitionId,
+      userId: ctx.userId,
+      tenantId: scope.tenantId
+    });
+    let draft;
+    if (existingDraft) {
+      existingDraft.deletedAt = null;
+      existingDraft.organizationId = scope.organizationId ?? existingDraft.organizationId;
+      existingDraft.definition = parsed.data;
+      if (input.metadata !== void 0) {
+        existingDraft.metadata = input.metadata;
+      }
+      existingDraft.baseUpdatedAt = definition.updatedAt;
+      draft = existingDraft;
+    } else {
+      draft = em.create(WorkflowDefinitionDraft, {
+        definitionId: input.definitionId,
+        userId: ctx.userId,
+        definition: parsed.data,
+        metadata: input.metadata ?? null,
+        baseUpdatedAt: definition.updatedAt,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId ?? definition.organizationId
+      });
+      em.persist(draft);
+    }
+    await em.flush();
+    const definitionData = parsed.data;
+    const ledger = await tryComputeLedger(ctx, definitionData);
+    const evaluation = evaluateWorkflowDefinition(definitionData, { ledger });
+    return {
+      ok: true,
+      issues: [],
+      draftId: draft.id,
+      definitionId: input.definitionId,
+      // The published definition was not touched, and its optimistic lock was
+      // not taken — drafts deliberately sit outside it.
+      published: false,
+      definitionUpdatedAt: definition.updatedAt.toISOString(),
+      problems: evaluation.problems,
+      errorCount: evaluation.errorCount,
+      warningCount: evaluation.warningCount
+    };
+  }
+};
+const startTestRunInput = z.object({
+  workflowId: z.string().min(1).describe("The definition workflowId to test"),
+  version: z.number().int().positive().optional(),
+  initialContext: z.record(z.string(), z.unknown()).optional().describe("Starting workflow context, shaped by the definition contextSchema.input"),
+  correlationKey: z.string().optional()
+});
+const startTestRunTool = {
+  name: "workflows.start_test_run",
+  displayName: "Start a workflow dry run",
+  description: 'Start an isolated DRY RUN of a workflow and return the "would do" report: every side effect the run suppressed, in order. Activities are simulated from their registry mocks (an activity with no mock refuses and stops the run), user tasks are recorded but never created, and nothing reaches real data. This is always a dry run \u2014 there is no option to make it real.',
+  inputSchema: startTestRunInput,
+  requiredFeatures: [INSTANCES_VIEW, INSTANCES_CREATE, DEFINITIONS_TEST_RUN],
+  tags: ["write", "workflows", "testing"],
+  isMutation: true,
+  handler: async (input, ctx) => {
+    const missing = missingFeatures(ctx, [INSTANCES_VIEW, INSTANCES_CREATE, DEFINITIONS_TEST_RUN]);
+    if (missing.length) return featureRefusal(missing);
+    const scope = resolveScope(ctx);
+    if (!scope) return failure(MISSING_TENANT_ISSUE);
+    if (!scope.organizationId) {
+      return failure(
+        issue(
+          ["organizationId"],
+          "missing_organization_context",
+          "An organization context is required to start a workflow run"
+        )
+      );
+    }
+    const em = resolveEm(ctx);
+    const definition = await findWorkflowDefinition(em, {
+      workflowId: input.workflowId,
+      version: input.version,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId
+    });
+    if (!definition) {
+      return failure(
+        issue(["workflowId"], "not_found", "Workflow definition not found", {
+          got: input.workflowId
+        })
+      );
+    }
+    if (isComponentKind(definition.kind)) {
+      return failure(
+        issue(
+          ["workflowId"],
+          "component_not_startable",
+          "This workflow is a reusable component and cannot be started standalone; invoke it from a SUB_WORKFLOW step"
+        )
+      );
+    }
+    const workflowExecutor = ctx.container.resolve("workflowExecutor");
+    const instance = await workflowExecutor.startWorkflow(em, {
+      workflowId: input.workflowId,
+      version: input.version,
+      initialContext: input.initialContext ?? {},
+      correlationKey: input.correlationKey,
+      metadata: { initiatedBy: ctx.userId ?? null },
+      // Forced, never an input. Dry-run isolation is the engine's own
+      // mechanism: mocked effectors, suppressed USER_TASKs, no enqueueing.
+      isDryRun: true,
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId
+    });
+    let executionError = null;
+    try {
+      await workflowExecutor.executeWorkflow(em, ctx.container, instance.id, {
+        userId: ctx.userId
+      });
+    } catch (error) {
+      executionError = error instanceof Error ? error.message : String(error);
+    }
+    const events = await em.find(
+      WorkflowEvent,
+      {
+        workflowInstanceId: instance.id,
+        tenantId: scope.tenantId,
+        organizationId: scope.organizationId,
+        eventType: {
+          $in: [
+            DRY_RUN_EVENT_TYPES.activitySimulated,
+            DRY_RUN_EVENT_TYPES.activityRefused,
+            DRY_RUN_EVENT_TYPES.userTaskSimulated,
+            DRY_RUN_EVENT_TYPES.businessRuleActionsSuppressed
+          ]
+        }
+      },
+      { orderBy: [{ occurredAt: "ASC" }, { id: "ASC" }], limit: 100 }
+    );
+    const stepInstanceIds = Array.from(
+      new Set(
+        events.map((event) => event.stepInstanceId).filter((id) => typeof id === "string" && id.length > 0)
+      )
+    );
+    const stepInstances = stepInstanceIds.length ? await em.find(StepInstance, {
+      id: { $in: stepInstanceIds },
+      tenantId: scope.tenantId,
+      organizationId: scope.organizationId
+    }) : [];
+    const stepIdByInstanceId = new Map(stepInstances.map((step) => [step.id, step.stepId]));
+    const sourceEvents = events.map((event) => ({
+      id: event.id,
+      eventType: event.eventType,
+      stepId: event.stepInstanceId ? stepIdByInstanceId.get(event.stepInstanceId) ?? null : null,
+      occurredAt: event.occurredAt,
+      eventData: event.eventData ?? null
+    }));
+    const report = buildWouldDoReport(sourceEvents);
+    const refreshed = await em.findOne(WorkflowInstance, {
+      id: instance.id,
+      tenantId: scope.tenantId
+    });
+    return {
+      ok: executionError === null,
+      issues: executionError ? [issue(["execution"], "execution_failed", executionError)] : [],
+      instanceId: instance.id,
+      isDryRun: true,
+      status: refreshed?.status ?? instance.status,
+      currentStepId: refreshed?.currentStepId ?? null,
+      wouldDo: report.entries,
+      stoppedByRefusal: report.stoppedByRefusal
+    };
+  }
+};
+const validateWorkflowDraftTool = {
+  name: "workflows.validate_workflow_definition",
+  displayName: "Validate a draft workflow definition",
+  description: "Validate a DRAFT workflow (the {summary, steps, transitions, contextSchema} object you are authoring) without saving it. Returns the same structured {path, code, message, expected, got} issues and Problems-panel entries the generate route would. Call this before returning a draft and fix every error \u2014 in particular, an INVOKE_AGENT activity requires a string `config.agentId` and a `config.onResult`.",
+  inputSchema: workflowDraftGenerationSchema,
+  requiredFeatures: [DEFINITIONS_CREATE],
+  tags: ["read", "workflows", "authoring"],
+  isMutation: false,
+  handler: async (input, ctx) => {
+    const missing = missingFeatures(ctx, [DEFINITIONS_CREATE]);
+    if (missing.length) return featureRefusal(missing);
+    const candidate = {
+      steps: input.steps,
+      transitions: input.transitions,
+      ...input.contextSchema ? { contextSchema: input.contextSchema } : {}
+    };
+    const parsed = workflowDefinitionDataSchema.safeParse(candidate);
+    if (!parsed.success) {
+      return failure(
+        ...parsed.error.issues.map(
+          (zodIssue) => issue(
+            [...zodIssue.path],
+            zodIssue.code,
+            zodIssue.message
+          )
+        )
+      );
+    }
+    const definitionData = asDefinitionData(parsed.data);
+    const ledger = await tryComputeLedger(ctx, definitionData);
+    const evaluation = evaluateWorkflowDefinition(definitionData, { ledger });
+    return {
+      ok: evaluation.valid,
+      issues: evaluation.issues,
+      problems: evaluation.problems,
+      valid: evaluation.valid,
+      errorCount: evaluation.errorCount,
+      warningCount: evaluation.warningCount
+    };
+  }
+};
+const workflowsAuthoringAiTools = [
+  listActivityTypesTool,
+  getContextSchemaTool,
+  validateDefinitionTool,
+  validateWorkflowDraftTool,
+  createDefinitionTool,
+  updateDefinitionTool,
+  startTestRunTool
+];
+var authoring_pack_default = workflowsAuthoringAiTools;
+export {
+  authoring_pack_default as default,
+  workflowsAuthoringAiTools
+};
+//# sourceMappingURL=authoring-pack.js.map