@uipath/case-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/{packager-tool-e3k5gzd3.js → packager-tool-a6wztj6y.js}

@@ -1,7 +1,16 @@
 import {
-  createTaskBindings,
+  resolveCaseSchemaVersion
+} from "./packager-tool-57pzrd0g.js";
+import {
+  createTaskBindings
+} from "./packager-tool-sq931c23.js";
+import {
+  CASE_PLAN_FILENAME,
+  buildMinimalCaseDocument
+} from "./packager-tool-xcd87qyx.js";
+import {
   prefixedId
-} from "./packager-tool-0mj06yen.js";
+} from "./packager-tool-mknccck5.js";
 import {
   DEFAULT_TRIGGER_ID,
   DEFAULT_TRIGGER_LABEL,
@@ -20,18 +29,18 @@ import {
   remapBindingRefs,
   requireStageNode,
   requireTask
-} from "./packager-tool-sv0d6wb6.js";
+} from "./packager-tool-nj4seavy.js";
 import {
   registerSharedIncidentCommands,
   registerSharedInstanceCommands,
   registerSharedProcessCommands,
   registerSharedProcessesCommands
-} from "./packager-tool-cg2j4rma.js";
+} from "./packager-tool-kacqd7h7.js";
 import {
   GET_SEARCHABLE_TYPES,
   RESOURCE_TYPES,
   TYPECACHE_INDEX_TYPES
-} from "./packager-tool-r84ng21s.js";
+} from "./packager-tool-sag9gz55.js";
 import {
   VALID_PROJECT_NAME_REGEX,
   formatTraceLine
@@ -43,15 +52,14 @@ import {
   catchError,
   createHiddenDeprecatedTenantOption,
   instructionsFor,
-  isPreviewBuild,
   logger,
   mapPackageMetadataOptions,
   processContext,
   registerPackageMetadataOptions
-} from "./packager-tool-kpcjnxd1.js";
+} from "./packager-tool-58kx79ta.js";
 import {
   getFileSystem
-} from "./packager-tool-0v3s8r01.js";
+} from "./packager-tool-xdxr3ync.js";
 import {
   __require
 } from "./packager-tool-1yh8g550.js";
@@ -60,7 +68,7 @@ var package_default = {
   name: "@uipath/case-tool",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.203.0-preview.205",
+  version: "1.204.0-preview.206",
   description: "Manage Case Management instances, processes, and incidents.",
   private: false,
   repository: {
@@ -98,7 +106,7 @@ var package_default = {
   devDependencies: {
     "@uipath/auth": "workspace:*",
     "@uipath/builder-sdk": "workspace:*",
-    "@uipath/case-schema": "^0.1052.3",
+    "@uipath/case-schema": "0.1147.0",
     "@uipath/common": "workspace:*",
     "@uipath/filesystem": "workspace:*",
     "@uipath/integrationservice-sdk": "workspace:*",
@@ -131,11 +139,13 @@ var CASE_BINDINGS_SYNC_EXAMPLES = [
 ];
 var registerBindingsCommand = (program) => {
   const bindings = program.command("bindings").description("Generate the bindings_v2.json sidecar from a case plan. Required input to 'uip solution resources refresh' for solutions authored without opening Studio Web.").addHelpText("after", `
-The sidecar is a pure derivation of the case plan's root 'bindings' array: the
-'name' and 'folderPath' bindings that share a resourceKey collapse into one
-entry keyed by that resourceKey, and each distinct connection collapses the
-same way. Nothing else is read — no network call, no registry file — so the
-output depends only on the case plan you pass in.
+The sidecar is a pure derivation of the case plan: the 'name' and
+'folderPath' bindings that share a resourceKey collapse into one entry keyed
+by that resourceKey, each distinct connection collapses the same way, and each
+connector start trigger adds an 'EventTrigger' entry (and a 'Property' entry
+for its parameters) so the trigger is created on deploy. The only other file
+read is 'entry-points.json' beside the case plan, for each trigger's entry
+point id — no network call, no registry file.
 
 Generate it rather than writing it by hand. The consumer deserializes the
 on-disk 'key' field, so an entry written as 'resourceKey' has no identity and
@@ -145,7 +155,7 @@ invisible to 'uip solution resources refresh'.
 Subcommands:
   sync  Write 'bindings_v2.json' next to a case plan.`);
   bindings.command("sync").description("Derive bindings_v2.json from a case plan and write it into the same directory.").argument("<file>", "Path to the case plan JSON file. The output 'bindings_v2.json' is written next to it, overwriting any existing file.").examples(CASE_BINDINGS_SYNC_EXAMPLES).trackedAction(processContext, async (file) => {
-    const { syncCaseBindings } = await import("./case-bindings-service-1wxfghzd.js");
+    const { syncCaseBindings } = await import("./case-bindings-service-c2mze9vj.js");
     const [error, result] = await catchError(syncCaseBindings(file));
     if (error) {
       OutputFormatter.error({
@@ -527,40 +537,6 @@ var registerCaseExitConditionsCommand = (program) => {
   });
 };
 
-// src/utils/case-document.ts
-var CASE_SCHEMA_VERSION = "30.0.0";
-var CASE_PLAN_FILENAME = "caseplan.json";
-function buildMinimalCaseDocument(options) {
-  return {
-    id: prefixedId("case-", 10),
-    name: options.name,
-    version: CASE_SCHEMA_VERSION,
-    ...options.description !== undefined && {
-      description: options.description
-    },
-    bindings: [],
-    variables: { inputOutputs: [] },
-    metadata: {
-      caseIdentifier: options.caseIdentifier ?? options.name,
-      caseAppEnabled: options.caseAppEnabled ?? false,
-      caseIdentifierType: options.identifierType ?? "constant",
-      publishVersion: 2
-    },
-    nodes: [
-      {
-        id: DEFAULT_TRIGGER_ID,
-        type: "uipath.case.trigger",
-        data: {
-          typeVersion: "1.0.0",
-          display: { label: DEFAULT_TRIGGER_LABEL },
-          inputs: { serviceType: "None" }
-        }
-      }
-    ],
-    edges: []
-  };
-}
-
 // src/commands/cases.ts
 var CASES_ADD_EXAMPLES = [
   {
@@ -576,7 +552,7 @@ var CASES_ADD_EXAMPLES = [
         CaseIdentifierType: "constant",
         CaseAppEnabled: false,
         TriggerId: DEFAULT_TRIGGER_ID,
-        Version: "30.0.0"
+        Version: "32.0.3"
       }
     }
   }
@@ -649,7 +625,10 @@ var registerCasesCommand = (program) => {
       processContext.exit(1);
       return;
     }
-    const schema = buildMinimalCaseDocument(options);
+    const schema = buildMinimalCaseDocument({
+      ...options,
+      schemaVersion: await resolveCaseSchemaVersion()
+    });
     const triggerId = schema.nodes.find(isAnyTriggerNode)?.id;
     const [writeError] = await catchError(writeSchema(options.file, schema));
     if (writeError) {
@@ -780,7 +759,7 @@ var CASE_DEBUG_EXAMPLES = [
 ];
 function registerDebugCommand(program) {
   program.command("debug").description("Debug a case project by uploading to Studio Web and running a debug session").argument("<project-path>", "Path to the case project directory (must contain project.uiproj)").option("--folder-id <id>", "Orchestrator folder ID (OrganizationUnitId). Auto-detected if not provided.").option("--poll-interval <ms>", "Polling interval in milliseconds", "2000").option("--login-validity <minutes>", "Minimum minutes before token expiration to trigger a refresh (default: 10)", parseInt, 10).examples(CASE_DEBUG_EXAMPLES).trackedAction(processContext, async (projectPath, options) => {
-    const { getLoginStatusAsync } = await import("./index-fz4ttsde.js");
+    const { getLoginStatusAsync } = await import("./index-j2r3jb6c.js");
     const [loginError, loginStatus] = await catchError(getLoginStatusAsync({
       ensureTokenValidityMinutes: options.loginValidity
     }));
@@ -883,8 +862,8 @@ function registerDebugCommand(program) {
     logger.info(`  Tenant: ${tenantName} (${tenantId})`);
     logger.info(`  Base URL: ${baseUrl}`);
     const pollInterval = parseInt(options.pollInterval || "2000", 10);
-    const { CaseDebugStudioWebService } = await import("./case-debug-studio-web-service-shg84pn8.js");
-    const { DebugPollTimeoutError, buildPollTimeoutFailureOutput } = await import("./debug-service-8x087xxt.js");
+    const { CaseDebugStudioWebService } = await import("./case-debug-studio-web-service-cc0vj7md.js");
+    const { DebugPollTimeoutError, buildPollTimeoutFailureOutput } = await import("./debug-service-vf5mw0nr.js");
     const service = new CaseDebugStudioWebService;
     logger.info(`Starting Studio Web debug session for: ${projectPath}`);
     const [executeError, result] = await catchError(service.executeProjectViaStudioWeb(projectPath, studioWebConfig, {
@@ -910,7 +889,7 @@ function registerDebugCommand(program) {
       const {
         buildSolutionUploadFailureOutput,
         isSolutionUploadHttpError
-      } = await import("./index-va9sm89y.js");
+      } = await import("./index-ynnr55wk.js");
       if (isSolutionUploadHttpError(executeError)) {
         OutputFormatter.error(buildSolutionUploadFailureOutput(executeError, {
           subject: "case",
@@ -1025,7 +1004,7 @@ function requireEdge(schema, edgeId) {
 }
 function isTriggerSource(schema, sourceId) {
   const sourceNode = schema.nodes.find((n) => n.id === sourceId);
-  return sourceNode?.type === "case-management:Trigger";
+  return sourceNode !== undefined && isAnyTriggerNode(sourceNode);
 }
 var registerEdgesCommand = (program) => {
   const edges = program.command("edges").description("Manage edges within a case management definition JSON file");
@@ -1256,7 +1235,7 @@ var CASE_FORMAT_EXAMPLES = [
 ];
 var registerFormatCommand = (program) => {
   program.command("format").description("Rewrite a case plan JSON file pretty-printed (2-space indent, one key per line) so it can be patched with a file-edit tool.").argument("<file>", "Path to the case plan JSON file, rewritten in place").examples(CASE_FORMAT_EXAMPLES).trackedAction(processContext, async (file) => {
-    const { formatCasePlan } = await import("./case-format-service-q345a2fd.js");
+    const { formatCasePlan } = await import("./case-format-service-qwyjyt0y.js");
     const [error, result] = await catchError(formatCasePlan(file));
     if (error) {
       OutputFormatter.error({
@@ -1319,7 +1298,7 @@ var initCaseProject = async (name, options) => {
     throw new Error(`Invalid project name "${name}". Name can only contain letters, numbers, underscores (_), and hyphens (-).`);
   }
   const fs = getFileSystem();
-  const { prepareProjectLocation, tryRegisterProjectInParentSolution } = await import("./index-va9sm89y.js");
+  const { prepareProjectLocation, tryRegisterProjectInParentSolution } = await import("./index-ynnr55wk.js");
   const { projectDir, autoCreatedSolution } = await prepareProjectLocation(fs, fs.path.resolve(name), name, { skipRegistration: options.skipSolutionRegistration === true });
   const projectDirExists = await fs.stat(projectDir).then(() => true).catch((err) => {
     const code = err instanceof Error ? err.code : undefined;
@@ -1406,13 +1385,16 @@ var initCaseProject = async (name, options) => {
   const casePlanPath = fs.path.join(projectDir, CASE_PLAN_FILENAME);
   const casePlanExists = await fs.exists(casePlanPath);
   if (!casePlanExists) {
-    await fs.writeFile(casePlanPath, `${JSON.stringify(buildMinimalCaseDocument({ name }), null, 4)}
+    await fs.writeFile(casePlanPath, `${JSON.stringify(buildMinimalCaseDocument({
+      name,
+      schemaVersion: await resolveCaseSchemaVersion()
+    }), null, 4)}
 `);
   }
   const solutionRegistration = await tryRegisterProjectInParentSolution(fs, projectDir, { skipRegistration: options.skipSolutionRegistration === true });
   let projectArtifacts;
   if ((solutionRegistration.Status === "Registered" || solutionRegistration.Status === "AlreadyRegistered") && solutionRegistration.Solution && solutionRegistration.ProjectId) {
-    const { ensureProjectArtifacts } = await import("./project-artifacts-8snev67g.js");
+    const { ensureProjectArtifacts } = await import("./project-artifacts-wzrhketn.js");
     projectArtifacts = await ensureProjectArtifacts({
       solutionDir: fs.path.dirname(solutionRegistration.Solution),
       projectId: solutionRegistration.ProjectId,
@@ -1467,8 +1449,8 @@ var registerInstancesCommand = (program) => {
 };
 
 // src/commands/job.ts
-var loadAuth = () => import("./index-fz4ttsde.js");
-var loadCaseApi = () => import("./case-api-v6cjyrfw.js");
+var loadAuth = () => import("./index-j2r3jb6c.js");
+var loadCaseApi = () => import("./case-api-gdaj9469.js");
 var CASE_JOB_STATUS_EXAMPLES = [
   {
     Description: "Get detailed status of a case job",
@@ -1714,7 +1696,7 @@ var CASE_PACK_EXAMPLES = [
 var registerPackCommand = (program) => {
   const command = program.command("pack").description("Pack a Case project into a .nupkg file").argument("<project-path>", "Path to the Case project directory").argument("<output-path>", "Output directory where the .nupkg will be saved").option("-n, --name <name>", "Package name (default: project folder name)").option("-v, --version <version>", "Package version (default: 1.0.0)", "1.0.0");
   registerPackageMetadataOptions(command).examples(CASE_PACK_EXAMPLES).trackedAction(processContext, async (projectPath, outputPath, options) => {
-    const { CasePackService } = await import("./case-pack-service-29rza2q2.js");
+    const { CasePackService } = await import("./case-pack-service-47yrvmg0.js");
     const service = new CasePackService;
     const [error, result] = await catchError(service.execute(projectPath, {
       output: outputPath,
@@ -1796,8 +1778,8 @@ var CASE_PROCESS_RUN_EXAMPLES = [
     }
   }
 ];
-var loadAuth2 = () => import("./index-fz4ttsde.js");
-var loadCaseApi2 = () => import("./case-api-v6cjyrfw.js");
+var loadAuth2 = () => import("./index-j2r3jb6c.js");
+var loadCaseApi2 = () => import("./case-api-gdaj9469.js");
 function registerProcessCommand(program) {
   const processCmd = program.command("process").description("Manage Case processes");
   registerSharedProcessCommands(processCmd, { toolLabel: "Case" });
@@ -2035,7 +2017,7 @@ function registerProcessCommand(program) {
       }
       inputs = parsed;
     } else {
-      const { readStdin } = await import("./input-reader-pnh948bq.js");
+      const { readStdin } = await import("./input-reader-bb0ptk2v.js");
       const [stdinError, stdinData] = await catchError(readStdin());
       if (!stdinError && stdinData) {
         const [parseError, parsed] = await catchError(parseCaseInputs(stdinData));
@@ -2245,12 +2227,13 @@ var REGISTRY_SEARCH_EXAMPLES = [
         Filters: null,
         Type: null,
         ResultCount: 1,
+        Local: false,
         Resources: [
           {
-            resourceType: "typecache-activities",
-            resource: {
-              name: "InvoiceParser",
-              uiPathActivityTypeId: "a1b2c3d4-0000-0000-0000-000000000001"
+            ResourceType: "typecache-activities",
+            Resource: {
+              Name: "InvoiceParser",
+              UiPathActivityTypeId: "a1b2c3d4-0000-0000-0000-000000000001"
             }
           }
         ]
@@ -2266,11 +2249,12 @@ var REGISTRY_LIST_EXAMPLES = [
       Code: "ResourceListSuccess",
       Data: {
         ResourcesCount: 128,
+        Local: false,
         ResourceTypes: [
           { Type: "typecache-activities", Count: 80 },
           { Type: "typecache-triggers", Count: 48 }
         ],
-        resources: []
+        Resources: []
       }
     }
   }
@@ -2349,7 +2333,7 @@ Subcommands:
   search  Find resources by keyword and/or field filters
   get     Get full schema for a single resource`);
   registry.command("pull").description("Pull and sync data from Case registry").option("-f, --force", "Force refresh, ignore cache").option("-s, --solution-id <solutionId>", "Include the registry of the solution").examples(REGISTRY_PULL_EXAMPLES).trackedAction(processContext, async (options) => {
-    const { pullResources } = await import("./resourcesSyncService-pmfwz9cd.js");
+    const { pullResources } = await import("./resourcesSyncService-1ezvhcbc.js");
     const [mapError, promises] = catchError(() => RESOURCE_TYPES.map((type) => pullResources({
       force: options.force,
       solutionId: options.solutionId
@@ -2401,7 +2385,7 @@ Subcommands:
       processContext.exit(1);
       return;
     }
-    const { searchResources, searchResourcesWithFilters } = await import("./resourcesSyncService-pmfwz9cd.js");
+    const { searchResources, searchResourcesWithFilters } = await import("./resourcesSyncService-1ezvhcbc.js");
     let searchResult;
     if (options.filter) {
       const [parseError, filters] = catchError(() => parseFilterString(options.filter));
@@ -2459,7 +2443,7 @@ Subcommands:
     });
   });
   registry.command("list").description("List all resources (use pull to update list)").option("--local", "List only in-solution sibling project resources (requires a .uipx in the current directory, its parent, or grandparent). Skips the tenant cache.").examples(REGISTRY_LIST_EXAMPLES).trackedAction(processContext, async (options) => {
-    const { listLocalResources, listResources } = await import("./resourcesSyncService-pmfwz9cd.js");
+    const { listLocalResources, listResources } = await import("./resourcesSyncService-1ezvhcbc.js");
     let grouped;
     if (options.local) {
       const [localError, localGrouped] = await catchError(listLocalResources());
@@ -2506,7 +2490,7 @@ Subcommands:
     });
   });
   registry.command("get").description("Get resource(s) by identifier (entityKey or id)").argument("<identifier>", "The entityKey (process-types) or id (action-apps) of the resource").addOption(new Option("-t, --type <type>", `Limit search to a specific resource type (${GET_SEARCHABLE_TYPES.map((t) => t.type).join(", ")})`).choices(GET_SEARCHABLE_TYPES.map((t) => t.type))).option("--connection-id <id>", "Connection ID for connector-specific IS field metadata (custom fields). Only applies to typecache-* activity / trigger results.").option("--local", "Resolve the identifier against in-solution sibling project resources (requires a .uipx in the current directory, its parent, or grandparent). Skips the tenant cache. The identifier is the sibling's resource key or .uipx project Id.").examples(REGISTRY_GET_EXAMPLES).trackedAction(processContext, async (identifier, options) => {
-    const { getResources } = await import("./resourcesSyncService-pmfwz9cd.js");
+    const { getResources } = await import("./resourcesSyncService-1ezvhcbc.js");
     const [error, matches] = await catchError(getResources(identifier, options.type, {
       local: options.local
     }));
@@ -2543,11 +2527,11 @@ Subcommands:
       const id = m.resource.uiPathActivityTypeId;
       if (typeof id !== "string")
         return m;
-      const { lookupTypeCacheEntry } = await import("./connector-lookup-service-y7x6xsc6.js");
+      const { lookupTypeCacheEntry } = await import("./connector-lookup-service-c49pvfwb.js");
       const [lookupError, lookupResult] = await catchError(lookupTypeCacheEntry(id, m.resourceType));
       if (lookupError)
         return m;
-      const { enrichConnectorRegistryEntry } = await import("./connector-enrichment-service-h662r92z.js");
+      const { enrichConnectorRegistryEntry } = await import("./connector-enrichment-service-rg87npf0.js");
       const [enrichError, definitions] = await catchError(enrichConnectorRegistryEntry(lookupResult.config, options.connectionId));
       if (enrichError || definitions === null)
         return m;
@@ -2573,7 +2557,7 @@ Subcommands:
     });
   });
   registry.command("get-connector").description(`Look up a connector activity/trigger from the local TypeCache index. ${OUTPUT_CASING_HINT}`).addOption(new Option("-t, --type <type>", "Resource type").choices([...TYPECACHE_INDEX_TYPES]).makeOptionMandatory()).requiredOption("--activity-type-id <id>", "The uiPathActivityTypeId to look up").examples(REGISTRY_GET_CONNECTOR_EXAMPLES).trackedAction(processContext, async (options) => {
-    const { lookupTypeCacheEntry } = await import("./connector-lookup-service-y7x6xsc6.js");
+    const { lookupTypeCacheEntry } = await import("./connector-lookup-service-c49pvfwb.js");
     const [error, result] = await catchError(lookupTypeCacheEntry(options.activityTypeId, options.type));
     if (error) {
       OutputFormatter.error({
@@ -2594,7 +2578,7 @@ Subcommands:
     }, { preserveDataKeys: VERBATIM_REGISTRY_FIELDS });
   });
   registry.command("get-connection").description(`Look up a connector and fetch available connections from Integration Service. ${OUTPUT_CASING_HINT}`).addOption(new Option("-t, --type <type>", "Resource type").choices([...TYPECACHE_INDEX_TYPES]).makeOptionMandatory()).requiredOption("--activity-type-id <id>", "The uiPathActivityTypeId to look up").examples(REGISTRY_GET_CONNECTION_EXAMPLES).trackedAction(processContext, async (options) => {
-    const { fetchConnectorConnections, lookupTypeCacheEntry } = await import("./connector-lookup-service-y7x6xsc6.js");
+    const { fetchConnectorConnections, lookupTypeCacheEntry } = await import("./connector-lookup-service-c49pvfwb.js");
     const [lookupError, lookupResult] = await catchError(lookupTypeCacheEntry(options.activityTypeId, options.type));
     if (lookupError) {
       OutputFormatter.error({
@@ -2627,6 +2611,399 @@ Subcommands:
   });
 };
 
+// src/commands/sdd.ts
+var reportReadFailure = (file, error) => {
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    ErrorCode: "invalid_argument",
+    Retry: "RetryWillNotFix",
+    Message: `Could not read ${file}: ${error?.message ?? "the file is no longer there"}`,
+    Instructions: `Check that ${file} is a readable text file.`
+  });
+  processContext.exit(1);
+};
+var reportParseFailure = (file, error) => {
+  OutputFormatter.error({
+    Result: RESULTS.Failure,
+    ErrorCode: "invalid_argument",
+    Retry: "RetryWillNotFix",
+    Message: `Could not parse ${file}: ${error.message}`,
+    Instructions: "The document is read as Markdown. Check that its tables are well formed."
+  });
+  processContext.exit(1);
+};
+var SDD_PARSE_EXAMPLES = [
+  {
+    Description: "Read an SDD and print the structured model the --sdd audit checks a caseplan against",
+    Command: "uip maestro case sdd parse sdd.md",
+    Output: {
+      Code: "SddParse",
+      Data: {
+        File: "sdd.md",
+        Model: {
+          stages: [
+            {
+              name: "Stage One",
+              tasks: [
+                { name: "Wait Timer", type: "wait-for-timer" }
+              ],
+              intake: { entryRows: 1, exitRows: 1 }
+            }
+          ],
+          triggers: 1,
+          variables: ["invoiceId"],
+          intake: { sawVariableSection: true, parseNotes: [] }
+        }
+      }
+    }
+  }
+];
+var SDD_RESOLVE_EXAMPLES = [
+  {
+    Description: "Resolve an SDD's task resources against the pulled registry caches",
+    Command: "uip maestro case sdd resolve sdd.md --out tasks/registry-resolved.json",
+    Output: {
+      Code: "SddResolve",
+      Data: {
+        File: "sdd.md",
+        Out: "tasks/registry-resolved.json",
+        Counts: { tasks: 15, selected: 13, ambiguous: 1, absent: 1 },
+        Unresolved: [
+          {
+            name: "SimpleApprovalApp",
+            taskType: "action",
+            reason: "ambiguous",
+            usages: [
+              { stage: "Stage 2", task: "Manager Approval" }
+            ],
+            creatable: false
+          }
+        ]
+      }
+    }
+  }
+];
+var SDD_CONVERT_EXAMPLES = [
+  {
+    Description: "Emit a case plan from an SDD, and list what the SDD does not determine",
+    Command: "uip maestro case sdd convert sdd.md --out caseplan.json",
+    Output: {
+      Code: "SddConvert",
+      Data: {
+        File: "sdd.md",
+        Out: "caseplan.json",
+        Derived: { stages: 8, tasks: 15, conditions: 11, variables: 0 },
+        Unresolved: [
+          {
+            kind: "resource-binding",
+            where: "nodes[Stage 1].data.tasks[Analyze Expense Request]",
+            detail: 'a "agent" task runs a tenant resource; its name and folder have to be resolved and bound before the plan can deploy'
+          }
+        ]
+      }
+    }
+  }
+];
+var registerSddCommand = (program) => {
+  const sdd = program.command("sdd").description("Read and inspect a Solution Design Document (sdd.md) — the document `validate --sdd` audits a case plan against.");
+  sdd.command("parse").description("Print the structured model parsed out of an sdd.md, as JSON. Reads the document only: it audits nothing and needs no case plan. Fields under `intake` describe the read (row counts, whether a section was seen, parser notes) rather than the document.").argument("<file>", "Path to the sdd.md to read").examples(SDD_PARSE_EXAMPLES).trackedAction(processContext, async (file) => {
+    const { getFileSystemAsync } = await import("./index-hhsf00x8.js");
+    const fs = await getFileSystemAsync();
+    if (!await fs.exists(file)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Retry: "RetryWillNotFix",
+        Message: `No such file: ${file}`,
+        Instructions: "Pass the path to an sdd.md. `uip maestro case sdd parse --help` shows an example."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [readError, text] = await catchError(fs.readFile(file, "utf-8"));
+    if (readError || text === null) {
+      reportReadFailure(file, readError);
+      return;
+    }
+    const { parseSddToJson } = await import("./strict-sdd-audit-k6hh0mbr.js");
+    const [parseError, model] = catchError(() => parseSddToJson(text));
+    if (parseError) {
+      reportParseFailure(file, parseError);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "SddParse",
+      Data: { File: file, Model: model }
+    }, { preserveDataKeys: ["model"] });
+  });
+  sdd.command("resolve").description("Resolve an sdd.md's task resources against the caches `registry pull` wrote. Does the part of the registry gate that has one right answer — which index a task type uses, the exact-name search, the folder narrowing — and reports the part that does not: a name matching several resources is left for a person to choose between, and a name matching none is grouped for one batched question. Reads caches only: no tenant, no network.").argument("<file>", "Path to the sdd.md to resolve").option("--out <file>", "Write the resolved file to this path instead of printing it").examples(SDD_RESOLVE_EXAMPLES).trackedAction(processContext, async (file, options) => {
+    const { getFileSystemAsync } = await import("./index-hhsf00x8.js");
+    const fs = await getFileSystemAsync();
+    if (!await fs.exists(file)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Retry: "RetryWillNotFix",
+        Message: `No such file: ${file}`,
+        Instructions: "Pass the path to an sdd.md. `uip maestro case sdd resolve --help` shows an example."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [readError, text] = await catchError(fs.readFile(file, "utf-8"));
+    if (readError || text === null) {
+      reportReadFailure(file, readError);
+      return;
+    }
+    const { parseSddToJson } = await import("./strict-sdd-audit-k6hh0mbr.js");
+    const { resolveSddResources } = await import("./sdd-resolve-service-4hx64x3z.js");
+    const [parseError, model] = catchError(() => parseSddToJson(text));
+    if (parseError) {
+      reportParseFailure(file, parseError);
+      return;
+    }
+    const result = await resolveSddResources(model);
+    const counts = {
+      tasks: result.resolved.length,
+      selected: result.resolved.filter((one) => one.selected !== null).length,
+      ambiguous: result.unresolved.filter((one) => one.reason === "ambiguous").length,
+      absent: result.unresolved.filter((one) => one.reason === "absent").length
+    };
+    if (options.out !== undefined) {
+      const payload = {
+        resolved: result.resolved,
+        unresolved: result.unresolved,
+        scope: result.scope
+      };
+      const [writeError] = await catchError(fs.writeFile(options.out, `${JSON.stringify(payload, null, 2)}
+`));
+      if (writeError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "unknown_error",
+          Message: `Could not write ${options.out}: ${writeError.message}`,
+          Instructions: "Check that the target directory exists and is writable."
+        });
+        processContext.exit(1);
+        return;
+      }
+    }
+    const { staleCacheWarning } = await import("./sdd-resolve-service-4hx64x3z.js");
+    const warnings = [
+      ...result.scope.missingIndexes.map((missing) => `The \`${missing}\` index is not pulled, so tasks needing it were not searched. Run \`uip maestro case registry pull\`.`),
+      staleCacheWarning(result.scope.cache)
+    ].filter((line) => line !== undefined);
+    for (const line of warnings)
+      logger.warn(line);
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "SddResolve",
+      Data: {
+        File: file,
+        ...options.out !== undefined && {
+          Out: options.out
+        },
+        Counts: counts,
+        Scope: result.scope,
+        ...warnings.length > 0 && { Warnings: warnings },
+        Unresolved: result.unresolved,
+        ...options.out === undefined && {
+          Resolved: result.resolved
+        }
+      }
+    }, {
+      preserveDataKeys: [
+        "resolved",
+        "unresolved",
+        "counts",
+        "scope",
+        "searchQuery",
+        "cacheFile",
+        "taskType",
+        "identifierField"
+      ]
+    });
+  });
+  sdd.command("convert").description("Emit a case plan from an sdd.md. Writes only what the document determines and reports what it does not — a resource that has to be resolved against a tenant, a cross-task reference, a connector's connection. The result is checked with `case validate`, not here.").argument("<file>", "Path to the sdd.md to convert").option("--out <file>", "Write the case plan to this path instead of printing it").option("--resolved <file>", "Read a `sdd resolve` file and use it to fill a resource name or folder the document left out").examples(SDD_CONVERT_EXAMPLES).trackedAction(processContext, async (file, options) => {
+    const { getFileSystemAsync } = await import("./index-hhsf00x8.js");
+    const fs = await getFileSystemAsync();
+    if (!await fs.exists(file)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Retry: "RetryWillNotFix",
+        Message: `No such file: ${file}`,
+        Instructions: "Pass the path to an sdd.md. `uip maestro case sdd convert --help` shows an example."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [readError, text] = await catchError(fs.readFile(file, "utf-8"));
+    if (readError || text === null) {
+      reportReadFailure(file, readError);
+      return;
+    }
+    const { parseSddToJson } = await import("./strict-sdd-audit-k6hh0mbr.js");
+    const { convertSddToCasePlan } = await import("./sdd-convert-service-gp9733qv.js");
+    let resolved;
+    let resolvedEntries = [];
+    if (options.resolved !== undefined) {
+      const [resolvedError, resolvedText] = await catchError(fs.readFile(options.resolved, "utf-8"));
+      if (resolvedError || resolvedText === null) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "invalid_argument",
+          Retry: "RetryWillNotFix",
+          Message: `Could not read ${options.resolved}: ${resolvedError?.message ?? "empty file"}`,
+          Instructions: `Write it with \`uip maestro case sdd resolve ${file} --out ${options.resolved}\` first.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      const [parseError2, parsed] = catchError(() => JSON.parse(resolvedText));
+      if (parseError2 || parsed === null) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "invalid_argument",
+          Retry: "RetryWillNotFix",
+          Message: `${options.resolved} is not valid JSON: ${parseError2?.message ?? "empty"}`,
+          Instructions: `Write it with \`uip maestro case sdd resolve ${file} --out ${options.resolved}\`.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      const entries = parsed.resolved;
+      if (entries === undefined) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "invalid_argument",
+          Retry: "RetryWillNotFix",
+          Message: `${options.resolved} has no \`resolved\` array, so there is nothing to read task resources from.`,
+          Instructions: `Write it with \`uip maestro case sdd resolve ${file} --out ${options.resolved}\`, which writes \`resolved\` as an array of one entry per task.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      if (!Array.isArray(entries)) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "invalid_argument",
+          Retry: "RetryWillNotFix",
+          Message: `${options.resolved} has a \`resolved\` key that is not an array, so there is nothing to read task resources from.`,
+          Instructions: `Write it with \`uip maestro case sdd resolve ${file} --out ${options.resolved}\`, which writes \`resolved\` as an array of one entry per task.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      const byTask = new Map;
+      const malformed = (entries ?? []).findIndex((entry) => entry === null || typeof entry !== "object" || Array.isArray(entry));
+      if (malformed !== -1) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "invalid_argument",
+          Retry: "RetryWillNotFix",
+          Message: `${options.resolved} has a \`resolved\` entry at index ${malformed} that is not an object, so there is no task to read a resource for.`,
+          Instructions: `Write it with \`uip maestro case sdd resolve ${file} --out ${options.resolved}\`, which writes each entry as an object carrying \`stage\`, \`task\` and \`selected\`.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      const { isDeferredEntry } = await import("./resolved-check-p99hysaw.js");
+      const deferred = new Set;
+      for (const entry of entries ?? []) {
+        if (isDeferredEntry(entry)) {
+          deferred.add(`${String(entry.stage ?? "")}\x01${String(entry.task ?? "")}`);
+          continue;
+        }
+        const picked = entry.selected;
+        if (picked === null || picked === undefined || typeof picked.name !== "string" || picked.name === "") {
+          continue;
+        }
+        byTask.set(`${String(entry.stage ?? "")}\x01${String(entry.task ?? "")}`, {
+          name: picked.name,
+          ...typeof picked.folder === "string" && {
+            folder: picked.folder
+          }
+        });
+      }
+      resolved = { byTask, deferred };
+      resolvedEntries = entries ?? [];
+    }
+    const [parseError, model] = catchError(() => parseSddToJson(text));
+    if (parseError) {
+      reportParseFailure(file, parseError);
+      return;
+    }
+    const { staleResolvedEntry } = await import("./resolved-check-p99hysaw.js");
+    const stale = staleResolvedEntry(model, resolvedEntries);
+    if (stale !== undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Retry: "RetryWillNotFix",
+        Message: `${options.resolved} does not match ${file}: ${stale}.`,
+        Instructions: `Resolve this SDD again: \`uip maestro case sdd resolve ${file} --out ${options.resolved}\`.`
+      });
+      processContext.exit(1);
+      return;
+    }
+    const fromFile = fs.path.basename(file).replace(/\.md$/i, "").replace(/^sdd[-_.]?/i, "");
+    const fallback = fromFile === "" ? "case" : fromFile;
+    const result = convertSddToCasePlan(model, {
+      name: model.caseName ?? fallback,
+      schemaVersion: await resolveCaseSchemaVersion(),
+      ...model.caseDescription !== undefined && {
+        description: model.caseDescription
+      },
+      ...resolved !== undefined && { resolved }
+    });
+    if (options.out !== undefined) {
+      const { correctedConvert, projectsBelowOut } = await import("./out-target-1f4n9vqb.js");
+      const meant = await projectsBelowOut(fs, options.out);
+      if (meant.length > 0) {
+        const corrected = meant.length === 1 ? correctedConvert(file, meant[0], options.resolved) : undefined;
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "invalid_argument",
+          Retry: "RetryWillNotFix",
+          Message: `${options.out} is not in a case project, and the folder holding it contains ${meant.length === 1 ? "one" : `${meant.length}`}: ${meant.join(", ")}. Writing here leaves a second case plan beside the project's.`,
+          Instructions: meant.length === 1 ? corrected === undefined ? `Pass \`--out\` as ${meant[0]}, the caseplan.json inside the project.` : `Write into the project: \`${corrected}\`.` : `Pass \`--out\` as the caseplan.json path inside the project you mean — one of ${meant.join(", ")}.`
+        });
+        processContext.exit(1);
+        return;
+      }
+      const [writeError] = await catchError(fs.writeFile(options.out, `${JSON.stringify(result.document, null, 2)}
+`));
+      if (writeError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "unknown_error",
+          Message: `Could not write ${options.out}: ${writeError.message}`,
+          Instructions: "Check that the target directory exists and is writable."
+        });
+        processContext.exit(1);
+        return;
+      }
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "SddConvert",
+      Data: {
+        File: file,
+        ...options.out !== undefined && {
+          Out: options.out
+        },
+        Derived: result.derived,
+        Unresolved: result.unresolved,
+        ...options.out === undefined && {
+          Document: result.document
+        }
+      }
+    }, { preserveDataKeys: ["document", "unresolved", "derived"] });
+  });
+};
+
 // src/commands/sla.ts
 var VALID_UNITS = ["min", "h", "d", "w", "m"];
 var SLA_SET_EXAMPLES = [
@@ -3341,8 +3718,8 @@ var SPEC_EXAMPLES = [
     }
   },
   {
-    Description: "Get the full spec for a curated connector trigger (Email Received)",
-    Command: "uip maestro case spec --type trigger --activity-type-id 7dc57f24-894c-5ae2-a902-66056fa40609 --connection-id fc82e610-c454-4bc7-a1a5-b5aa529d1ba6",
+    Description: "Get the full spec for a curated connector start trigger (Email Received)",
+    Command: "uip maestro case spec --type trigger --trigger-kind start --activity-type-id 7dc57f24-894c-5ae2-a902-66056fa40609 --connection-id fc82e610-c454-4bc7-a1a5-b5aa529d1ba6",
     Output: {
       Code: "ConnectorTaskSpec",
       Data: {
@@ -3367,7 +3744,7 @@ var SPEC_EXAMPLES = [
   }
 ];
 var registerSpecCommand = (program) => {
-  program.command("spec").description(`Generate a normalized ConnectorTaskSpec — a one-stop description of everything a consumer needs to construct a runnable Integration Service activity or trigger task. Looks up the typeId in the local TypeCache, lists IS connections for the connector, and fetches IS metadata. ${OUTPUT_CASING_HINT}`).addOption(new Option("--type <type>", "TypeCache to look up").choices(["activity", "trigger"]).makeOptionMandatory()).requiredOption("--activity-type-id <uuid>", "Studio Web uiPathActivityTypeId — found via 'uip maestro case registry pull' + reading typecache-{activities,triggers}-index.json or 'uip maestro case registry get-connector'").requiredOption("--connection-id <id>", "Connection UUID. List candidates with `uip maestro case registry get-connection --type typecache-{activities,triggers} --activity-type-id <uuid>` and pick one before invoking spec.").option("--object-name <name>", "Override the typecache objectName. Required for entity-typed Curated triggers whose typecache stores a placeholder (e.g. Data Service `{tenantEntityName|folderEntityName}` — pick a real entity name).").option("--skip-case-shape", "Omit `caseShape` (`inputs[]`, `outputs[]`, `context[]`) from the response. Use during the planning phase when the caller only needs the connector contract (`inputs.*[?required]`, `references[*].discoverCommand`, `outputs.responseFields`). Re-run without the flag during implementation to get the full caseShape scaffold. Mutually exclusive with --input-details.").option("--input-details <json>", "JSON values to fold into the generated `caseShape`. Activity accepts {bodyParameters, queryParameters, pathParameters, filter}; trigger accepts {eventParameters, filter}. See `packages/case-tool/docs/spec-input-details.md` for the full reference. Mutually exclusive with --skip-case-shape.").examples(SPEC_EXAMPLES).trackedAction(processContext, async (options) => {
+  program.command("spec").description(`Generate a normalized ConnectorTaskSpec — a one-stop description of everything a consumer needs to construct a runnable Integration Service activity or trigger task. Looks up the typeId in the local TypeCache, lists IS connections for the connector, and fetches IS metadata. ${OUTPUT_CASING_HINT}`).addOption(new Option("--type <type>", "TypeCache to look up").choices(["activity", "trigger"]).makeOptionMandatory()).requiredOption("--activity-type-id <uuid>", "Studio Web uiPathActivityTypeId — found via 'uip maestro case registry pull' + reading typecache-{activities,triggers}-index.json or 'uip maestro case registry get-connector'").requiredOption("--connection-id <id>", "Connection UUID. List candidates with `uip maestro case registry get-connection --type typecache-{activities,triggers} --activity-type-id <uuid>` and pick one before invoking spec.").option("--object-name <name>", "Override the typecache objectName. Required for entity-typed Curated triggers whose typecache stores a placeholder (e.g. Data Service `{tenantEntityName|folderEntityName}` — pick a real entity name).").addOption(new Option("--trigger-kind <kind>", "With --type trigger: 'start' for a case start trigger (Intsvc.EventTrigger on a trigger node, runtime type CuratedTrigger) or 'wait-for' for a wait-for-connector task or condition rule (runtime type CuratedWaitFor). Ignored for --type activity.").choices(["start", "wait-for"]).default("wait-for")).option("--skip-case-shape", "Omit `caseShape` (`inputs[]`, `outputs[]`, `context[]`) from the response. Use during the planning phase when the caller only needs the connector contract (`inputs.*[?required]`, `references[*].discoverCommand`, `outputs.responseFields`). Re-run without the flag during implementation to get the full caseShape scaffold. Mutually exclusive with --input-details.").option("--input-details <json>", "JSON values to fold into the generated `caseShape`. Activity accepts {bodyParameters, queryParameters, pathParameters, filter}; trigger accepts {eventParameters, queryParameters, pathParameters, filter}. See `packages/case-tool/docs/spec-input-details.md` for the full reference. Mutually exclusive with --skip-case-shape.").examples(SPEC_EXAMPLES).trackedAction(processContext, async (options) => {
     logger.info(`Fetching ${options.type} spec for typeId ${options.activityTypeId} (connection: ${options.connectionId})`);
     let parsedInputDetails;
     if (options.inputDetails !== undefined) {
@@ -3395,9 +3772,10 @@ var registerSpecCommand = (program) => {
     const fetchOpts = {
       objectNameOverride: options.objectName,
       skipCaseShape: options.skipCaseShape === true,
+      triggerKind: options.triggerKind,
       inputDetails: parsedInputDetails
     };
-    const { fetchConnectorTaskSpec } = await import("./connector-task-spec-qm6q8qma.js");
+    const { fetchConnectorTaskSpec } = await import("./connector-task-spec-t3tjeeqt.js");
     const [error, spec] = await catchError(fetchConnectorTaskSpec(options.type, options.activityTypeId, options.connectionId, fetchOpts));
     if (error) {
       OutputFormatter.error({
@@ -3416,6 +3794,196 @@ var registerSpecCommand = (program) => {
   });
 };
 
+// src/commands/splice.ts
+var SPLICE_EXAMPLES = [
+  {
+    Description: "Splice a connector activity's spec into the task that runs it",
+    Command: "uip maestro case splice caseplan.json --task-id tP6mWC2aG --spec slack-send.json",
+    Output: {
+      Code: "ConnectorShapeSpliced",
+      Data: {
+        Path: "caseplan.json",
+        Summary: {
+          TaskId: "tP6mWC2aG",
+          TaskType: "execute-connector-activity",
+          ServiceType: "Intsvc.ActivityExecution",
+          ContextEntries: 8,
+          Inputs: 3,
+          Outputs: 0,
+          ConnectionBindingId: "bA1b2C3d",
+          FolderBindingId: "bD4e5F6g",
+          BindingsReused: false
+        }
+      }
+    }
+  }
+];
+var registerSpliceCommand = (program) => {
+  program.command("splice").description("Write a connector task's `caseShape` from a `case spec` result into the task that runs it: `data.context` with the binding references resolved, `data.inputs`/`data.outputs` with their ids minted, the matching `serviceType`, and the connection's root bindings. Does the transport by hand-carrying nothing — the shape comes from the spec, the bindings from the binding builder, the service type from the task's own type. Offline: it reads the spec you hand it and never fetches one.").argument("<file>", "Path to the case plan to splice into").option("--task-id <task-id>", "Id of the connector task to write into, from `nodes[].data.tasks[][].id`. Pass this or --task-name.").option("--task-name <task-name>", "Display name of the task to write into, exactly as the plan spells it — same case and spacing, the way the SDD audit compares it. Pass this or --task-id.").option("--described <file>", "A `uip maestro case tasks describe` result saved as JSON. Writes a resource task's inputs and outputs from the resource's own contract — types, schemas and options — keeping the ids the plan already carries. Use instead of --spec for a process, rpa, api-workflow, agent, action, function or child-case task.").option("--spec <file>", "A `uip maestro case spec` result saved as JSON — the envelope as written, `Data.CaseShape` and all. A bare shape or an older PascalCased save is read too. Must carry the shape: run spec without `--skip-case-shape`.").option("--connection-id <id>", "Connection UUID the task runs against. Optional: it defaults to the connection the spec was fetched for, which the spec's own `caseShape.context.resourceKey` states. Pass it to override, and a value that disagrees with the spec is refused. The root bindings are keyed on it, so splicing twice for the same connection reuses them rather than appending a second pair.").option("--folder-key <key>", "Folder key for the connection. Optional: it defaults to the folder the spec's own `Data.Connection.FolderKey` states, and a value that disagrees with the spec is refused. When the connection has no folder, `case spec` returns a shape with no `folderKey` entry, and this drops any folder binding left over for that connection rather than leaving one with no `default`. If the shape asks for a folder binding and neither this nor the spec gives one, that is refused rather than written.").option("--out <file>", "Write the spliced plan here instead of in place").examples(SPLICE_EXAMPLES).trackedAction(processContext, async (file, options) => {
+    const { getFileSystemAsync } = await import("./index-hhsf00x8.js");
+    const fs = await getFileSystemAsync();
+    const mode = options.described !== undefined ? "described" : "spec";
+    if (options.described === undefined === (options.spec === undefined)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Message: "Pass exactly one of --spec or --described",
+        Instructions: "--spec splices a connector's `case spec` shape; --described writes a resource task's `case tasks describe` contract.",
+        Retry: "RetryWillNotFix"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const source = options.described ?? options.spec;
+    const missing = [file, source].filter((path) => path !== undefined);
+    for (const path of missing) {
+      if (await fs.exists(path))
+        continue;
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Message: `File not found: ${path}`,
+        Instructions: "Pass an existing case plan and an existing `case spec` result.",
+        Retry: "RetryWillNotFix"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const read = async (path) => {
+      const text = await fs.readFile(path, "utf-8") ?? "";
+      const [error, parsed] = catchError(() => JSON.parse(text));
+      if (error)
+        return;
+      return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
+    };
+    const plan = await read(file);
+    const specDocument = await read(source);
+    if (plan === undefined || specDocument === undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Message: `${plan === undefined ? file : String(source)} is not a JSON object`,
+        Instructions: "Both inputs are JSON documents. Save the spec with `--output json`.",
+        Retry: "RetryWillNotFix"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const { isTaskSelectorFailure, resolveTaskSelector } = await import("./task-selector-8bjn35dv.js");
+    const selected = resolveTaskSelector(plan, {
+      taskId: options.taskId,
+      taskName: options.taskName
+    });
+    if (isTaskSelectorFailure(selected)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Message: selected.message,
+        Instructions: selected.instructions,
+        Retry: "RetryWillNotFix"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const taskId = selected.id;
+    if (mode === "described") {
+      const { applyDescribedIo, isDescribedIoFailure } = await import("./case-described-io-service-cpe5h2ks.js");
+      const applied = applyDescribedIo(plan, specDocument, {
+        taskId
+      });
+      if (isDescribedIoFailure(applied)) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          ErrorCode: "invalid_argument",
+          Message: applied.message,
+          Instructions: applied.instructions,
+          Retry: "RetryWillNotFix"
+        });
+        processContext.exit(1);
+        return;
+      }
+      const target2 = options.out ?? file;
+      await fs.writeFile(target2, `${JSON.stringify(applied.document, null, 4)}
+`);
+      logger.info(`Wrote described I/O for ${taskId} into ${target2}`);
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "DescribedIoApplied",
+        Data: {
+          Path: target2,
+          Summary: {
+            TaskId: applied.summary.taskId,
+            InputsUpdated: applied.summary.inputsUpdated,
+            OutputsUpdated: applied.summary.outputsUpdated,
+            Unmatched: applied.summary.unmatched
+          },
+          NextSteps: "Run `uip maestro case validate <file> --strict` to check the task."
+        }
+      });
+      return;
+    }
+    const { readCaseShape, readSpecFolderKey } = await import("./case-shape-reader-mw58avr0.js");
+    const caseShape = readCaseShape(specDocument);
+    if (caseShape === undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Message: `${options.spec} carries no \`caseShape\``,
+        Instructions: "Re-run `uip maestro case spec` without `--skip-case-shape` and save that result.",
+        Retry: "RetryWillNotFix"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const { spliceConnectorShape, isSpliceFailure } = await import("./case-splice-service-9zvw19ca.js");
+    const result = spliceConnectorShape(plan, caseShape, {
+      taskId,
+      connectionId: options.connectionId,
+      folderKey: options.folderKey,
+      specFolderKey: readSpecFolderKey(specDocument)
+    });
+    if (isSpliceFailure(result)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_argument",
+        Message: result.message,
+        Instructions: result.instructions,
+        Retry: "RetryWillNotFix"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const target = options.out ?? file;
+    await fs.writeFile(target, `${JSON.stringify(result.document, null, 4)}
+`);
+    logger.info(`Spliced ${taskId} into ${target}`);
+    const { summary } = result;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ConnectorShapeSpliced",
+      Data: {
+        Path: target,
+        Summary: {
+          TaskId: summary.taskId,
+          TaskType: summary.taskType,
+          ServiceType: summary.serviceType,
+          ContextEntries: summary.contextEntries,
+          Inputs: summary.inputs,
+          Outputs: summary.outputs,
+          ConnectionBindingId: summary.connectionBindingId,
+          ...summary.folderBindingId !== undefined && {
+            FolderBindingId: summary.folderBindingId
+          },
+          BindingsReused: summary.bindingsReused,
+          BindingsCompleted: summary.bindingsCompleted,
+          BindingsDropped: summary.bindingsDropped
+        },
+        NextSteps: "Run `uip maestro case validate <file> --strict` to check the spliced task, then `uip maestro case bindings sync <file>` to bring bindings_v2.json in line."
+      }
+    });
+  });
+};
+
 // src/commands/stage-entry-conditions.ts
 var STAGE_ENTRY_CONDITIONS_ADD_EXAMPLES = [
   {
@@ -5263,9 +5831,9 @@ var TASKS_DESCRIBE_EXAMPLES = [
     }
   }
 ];
-var loadConnectorEnrichment = () => import("./connector-enrichment-service-h662r92z.js");
-var loadTriggerEnrichment = () => import("./trigger-enrichment-service-xexg7qbk.js");
-var loadEnrichment = () => import("./enrichment-service-7vbxcwge.js");
+var loadConnectorEnrichment = () => import("./connector-enrichment-service-rg87npf0.js");
+var loadTriggerEnrichment = () => import("./trigger-enrichment-service-pjw5ysny.js");
+var loadEnrichment = () => import("./enrichment-service-78b0gqck.js");
 var TASK_TYPES = [
   "process",
   "action",
@@ -5285,7 +5853,8 @@ var ENRICHABLE_TYPES = [
   "action",
   "api-workflow",
   "case-management",
-  "flow-process"
+  "flow-process",
+  "function"
 ];
 var EXTERNAL_DESCRIBE_INDEXES = {
   "external-workflow": "typecache-external-automation-activities",
@@ -5479,7 +6048,7 @@ async function describeConnectorActivity(id, connectionId, indexType = "typecach
 }
 async function describeConnectorTrigger(id, connectionId) {
   const { enrichConnectorTrigger, fetchTriggerFieldInfo } = await loadTriggerEnrichment();
-  const result = await enrichConnectorTrigger(id, connectionId);
+  const result = await enrichConnectorTrigger("wait-for", id, connectionId);
   const [, fieldInfo] = await catchError(fetchTriggerFieldInfo(result.config.connectorKey, result.config.objectName, result.config.eventOperation));
   const inputs = fieldInfo ? result.inputs.map((input) => {
     const all = fieldInfo.allFields[input.name];
@@ -5706,7 +6275,7 @@ var registerTasksCommand = (program) => {
       } else {
         const eventParams = parsedInputValues?.body ? Object.fromEntries(Object.entries(parsedInputValues.body).map(([k, v]) => [k, String(v)])) : undefined;
         const { enrichConnectorTrigger } = await loadTriggerEnrichment();
-        enrichment = await enrichConnectorTrigger(options.typeId, options.connectionId, eventParams);
+        enrichment = await enrichConnectorTrigger("wait-for", options.typeId, options.connectionId, eventParams);
         taskType = "wait-for-connector";
         serviceType = "Intsvc.WaitForEvent";
       }
@@ -6298,8 +6867,8 @@ var registerTriggersCommand = (program) => {
     const result = await readAndBuildTrigger(file, options.displayName, options.position, options.description);
     if (result.error)
       return;
-    const { enrichConnectorTrigger } = await import("./trigger-enrichment-service-xexg7qbk.js");
-    const [enrichError, enrichment] = await catchError(enrichConnectorTrigger(options.typeId, options.connectionId, parsedEventParams));
+    const { enrichConnectorTrigger } = await import("./trigger-enrichment-service-pjw5ysny.js");
+    const [enrichError, enrichment] = await catchError(enrichConnectorTrigger("start", options.typeId, options.connectionId, parsedEventParams));
     if (enrichError) {
       OutputFormatter.error({
         Result: RESULTS.Failure,
@@ -6431,11 +7000,11 @@ var toIssueData = (issues) => issues.map((issue) => ({
   Severity: issue.severity
 }));
 var suppressedAudit = async (file, shown) => {
-  const { findAdjacentSdd } = await import("./sdd-lookup-x08j9g9m.js");
+  const { findAdjacentSdd } = await import("./sdd-lookup-vpjej1kt.js");
   const [lookupError, sdd] = await catchError(Promise.resolve(findAdjacentSdd(file)));
   if (lookupError || sdd === undefined)
     return;
-  const { CaseValidateService } = await import("./case-validate-service-2n2bqc1g.js");
+  const { CaseValidateService } = await import("./case-validate-service-vrvx19c1.js");
   const [auditError, audited] = await catchError(new CaseValidateService().validateFileUsingSDK(file, {
     profile: "strict",
     sddPath: sdd
@@ -6451,7 +7020,7 @@ var suppressedAudit = async (file, shown) => {
   };
 };
 var executeCaseValidate = async (file, options = {}) => {
-  const { CaseValidateService } = await import("./case-validate-service-2n2bqc1g.js");
+  const { CaseValidateService } = await import("./case-validate-service-vrvx19c1.js");
   const service = new CaseValidateService;
   const [error, result] = await catchError(service.validateFileUsingSDK(file, {
     profile: resolveProfile(options),
@@ -6842,11 +7411,10 @@ var metadata = {
   commandPrefix: "case"
 };
 var registerCommands = async (program) => {
-  if (isPreviewBuild()) {
-    const { registerCaseAuthoringCommands } = await import("./authoring-kngaggwm.js");
-    registerCaseAuthoringCommands(program);
-  }
+  const { registerCaseAuthoringCommands } = await import("./authoring-0hr88kff.js");
+  registerCaseAuthoringCommands(program);
   registerInitCommand(program);
+  registerSddCommand(program);
   registerBindingsCommand(program);
   registerFormatCommand(program);
   registerPackCommand(program);
@@ -6862,6 +7430,7 @@ var registerCommands = async (program) => {
   registerTasksCommand(program);
   registerSlaCommand(program);
   registerSpecCommand(program);
+  registerSpliceCommand(program);
   registerTriggersCommand(program);
   registerStickyNotesCommand(program);
   registerEdgesCommand(program);
@@ -6876,4 +7445,4 @@ var registerCommands = async (program) => {
 
 export { metadata, registerCommands };
 
-//# debugId=75AB57A3115FA0D364756E2164756E21
+//# debugId=E5DD82D58051555764756E2164756E21