monday-cli 0.5.0 → 0.7.0

package/dist/commands/item/create.js

@@ -23,14 +23,30 @@
  *      v0.3 because the column-resolution path here assumes the
  *      classic auto-generated-subitems-board model.
  *
- * **Single round-trip** (cli-design §5.8 — hard exit gate). Every
- * translated `--set` / `--set-raw` value bundles into one
- * `create_item.column_values` (or `create_subitem.column_values`)
- * parameter via `bundleColumnValues`; the CLI does **not** fall back
- * to `create_item` + `change_multiple_column_values` on partial
- * failure. Monday's server-side rejection of any value fails the
- * whole mutation, and no item is created — agents retry with the
- * value fixed.
+ * **Single round-trip on the JSON-only path** (cli-design §5.8 —
+ * hard exit gate). Every translated non-file `--set` / `--set-raw`
+ * value bundles into one `create_item.column_values` (or
+ * `create_subitem.column_values`) parameter via `bundleColumnValues`;
+ * the CLI does **not** fall back to `create_item` +
+ * `change_multiple_column_values` on partial failure. Monday's
+ * server-side rejection of any value fails the whole mutation, and
+ * no item is created — agents retry with the value fixed.
+ *
+ * **Two-leg dispatch on the create-time file `--set` carve-out
+ * (v0.7-M43 D6 fold).** When any `--set <file-col>=<path>` is
+ * present, the action body partitions setEntries (non-file →
+ * leg-1's `column_values`; file → leg-2) and routes through
+ * `runItemCreateFileDispatch`: leg-1 `create_item` (or
+ * `create_subitem`) bundles the non-file column_values atomically;
+ * leg-2 `add_file_to_column` attaches the file via M31's multipart
+ * wire (reused verbatim through M38's `executeFileColumnSet`). The
+ * pair is non-atomic by construction; leg-2 failure surfaces
+ * `internal_error` with `details.reason:
+ * 'create_then_file_upload_partial_failure'` + `details.cause` +
+ * `details.created_item_id` echoing the orphan + a hint directing
+ * agents to retry leg-2 only OR rollback via `monday item delete`
+ * (cli-design §5.8 orphan-warn atomicity envelope, D1 closure). See
+ * `runItemCreateFileDispatch` below for the helper signature.
  *
  * **`--position` / `--relative-to` cross-validation.** Both flags
  * are required together (one without the other → `usage_error`).
@@ -50,22 +66,46 @@
 import { z } from 'zod';
 import { ensureSubcommand } from '../types.js';
 import { emitDryRun, emitMutation } from '../emit.js';
-import { resolveClient } from '../../api/resolve-client.js';
+import { resolveClient, } from '../../api/resolve-client.js';
 import { BoardIdSchema, ItemIdSchema } from '../../types/ids.js';
 import { parseArgv } from '../parse-argv.js';
 import { ApiError, MondayCliError, UsageError } from '../../utils/errors.js';
 import { bundleColumnValues, } from '../../api/column-values.js';
 import { parseSetRawExpression, } from '../../api/raw-write.js';
 import { splitSetExpression } from '../../api/set-expression.js';
-import { buildResolutionContexts } from '../../api/resolution-context.js';
+import { buildResolutionContexts, } from '../../api/resolution-context.js';
 import { lookupItemBoard, lookupItemBoardWithHierarchy, } from '../../api/item-board-lookup.js';
-import { SourceAggregator, mergeSourceWithPreflight, mergeCacheAge, } from '../../api/source-aggregator.js';
+import { SourceAggregator, mergeCacheAge, mergeSourceWithPreflight, } from '../../api/source-aggregator.js';
 import { resolveAndTranslate } from '../../api/resolution-pass.js';
-import { foldAndRemap } from '../../api/resolver-error-fold.js';
+import { executeFileColumnSet, preCheckM38FileDispatch, } from '../../api/file-column-set.js';
+import { foldAndRemap, mergeResolverWarningsIntoError, } from '../../api/resolver-error-fold.js';
 import { planCreate } from '../../api/dry-run.js';
 import { loadBoardMetadata } from '../../api/board-metadata.js';
 import { assertResponseFieldPresent } from '../../api/response-root.js';
 import { unwrapOrThrow } from '../../utils/parse-boundary.js';
+import { precheckLocalFile } from '../../utils/file-source.js';
+import { invalidateBoard } from '../../api/cache.js';
+/**
+ * Dedupes resolver warnings by `code + message + details.token`.
+ * v0.6-M38 IMPL round-2 P3-1 fix: M38 pre-check + downstream
+ * resolveAndTranslate / planCreate can both observe the same
+ * `stale_cache_refreshed` / `column_token_collision` warning;
+ * dedupe ensures each surfaces exactly once. Same shape as the
+ * bulk-update `dedupeWarnings` helper.
+ */
+const dedupeCreateWarnings = (warnings) => {
+    const seen = new Set();
+    const out = [];
+    for (const w of warnings) {
+        const tokenKey = typeof w.details?.token === 'string' ? w.details.token : '';
+        const key = `${w.code}|${w.message}|${tokenKey}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(w);
+    }
+    return out;
+};
 // ============================================================
 // GraphQL mutations. The parent lookup + relative-to lookup queries
 // live in api/item-board-lookup.ts (R23 lift).
@@ -420,13 +460,13 @@ const resolveCreateMode = async (inputs) => {
                 `creation is deferred. Use a classic board ` +
                 `(hierarchy_type null/"classic"). v0.3 M28 Decision 11 closure: ` +
                 `Monday's sub_items_board carries no subtasks column at API ` +
-                `2026-01, so depth-2 subitems have no data-model home — v0.6 ` +
+                `2026-01, so depth-2 subitems have no data-model home — v0.8 ` +
                 `picks the feature up if Monday surfaces the capability.`, {
                 details: {
                     parent_item_id: dispatch.parentItemId,
                     parent_board_id: parent.boardId,
                     hierarchy_type: parent.hierarchyType,
-                    deferred_to: 'v0.6',
+                    deferred_to: 'v0.8',
                 },
             });
         }
@@ -541,7 +581,7 @@ export const itemCreateCommand = {
             const parsed = parseArgv(itemCreateCommand.inputSchema, {
                 ...opts,
             });
-            const { client, globalFlags, apiVersion, toEmit } = resolveClient(ctx, program.opts());
+            const { client, globalFlags, apiVersion, multipart, toEmit } = resolveClient(ctx, program.opts());
             const dispatch = validateInputShape(parsed);
             // Argv-parse-time failures fire BEFORE any network call —
             // splits run on pure strings, JSON parse on `--set-raw` runs
@@ -578,57 +618,177 @@ export const itemCreateCommand = {
                 ? createMode.subitemsBoardId
                 : createMode.boardId;
             const { dateResolution, peopleResolution, tagResolution, relationResolution } = buildResolutionContexts({ client, ctx, globalFlags });
-            if (globalFlags.dryRun) {
-                const result = await planCreate({
+            // v0.6-M38 / v0.7-M43 D6 closure — create-time file-set
+            // dispatch routes through the column-resolution boundary's
+            // pre-check. Pre-checks setEntries against the resolved
+            // create-mode board (subitems board for subitem create;
+            // --board for top-level), then returns one of:
+            //   - `kind: 'json'` — no file column in `--set` (existing
+            //     bundled-create path runs below).
+            //   - `kind: 'file_create'` — clean single-file `--set`
+            //     entry; branches into the v0.7-M43 two-leg dispatch
+            //     helper {@link runItemCreateFileDispatch} (carve-out
+            //     fold from v0.6-M38's permanent rejection).
+            //   - Throws `usage_error` with
+            //     `details.reason: 'multi_file_set_unsupported'` on 2+
+            //     file `--set` entries (universal mutex rule). The
+            //     `'mixed_file_and_value_sets'` rule is SUPPRESSED on
+            //     `'item_create'` callShape per the v0.7-M43 D6 mixed-
+            //     rule asymmetry — `create_item` natively bundles
+            //     non-file `column_values` atomically into leg-1.
+            // `--set-raw <file-col>=<json>` stays at
+            // `translateRawColumnValue`'s D3 permanent rejection (the
+            // pre-check inspects setEntries only).
+            let m38Source;
+            let m38CacheAge = null;
+            let m38Warnings = [];
+            let m38FileCreate;
+            if (setEntries.length > 0) {
+                const m38 = await preCheckM38FileDispatch({
                     client,
-                    mode: createMode,
-                    name: parsed.name,
+                    boardId: resolveBoardId,
                     setEntries,
-                    ...(rawEntries.length === 0 ? {} : { rawEntries }),
+                    setRawCount: rawEntries.length,
+                    hasName: true,
+                    callShape: 'item_create',
+                    env: ctx.env,
+                    noCache: globalFlags.noCache,
+                });
+                m38Source = m38.source;
+                m38CacheAge = m38.cacheAgeSeconds;
+                m38Warnings = m38.warnings;
+                if (m38.kind === 'file_create') {
+                    m38FileCreate = m38;
+                }
+            }
+            // v0.6-M38 → v0.7-M43 D6 fold — branch into the two-leg
+            // dispatch helper. {@link runItemCreateFileDispatch} runs
+            // the upfront `precheckLocalFile` + partitions setEntries
+            // (non-file → leg-1 `column_values`, file → leg-2
+            // `add_file_to_column`) + dispatches leg-1 `create_item`
+            // / `create_subitem` then leg-2 `add_file_to_column` under
+            // the §5.8 orphan-warn atomicity envelope (D1 closure).
+            // Reaching this branch means argv parse + shape validation
+            // + duplicate-token check + create-mode resolution + M38
+            // pre-check all succeeded.
+            if (m38FileCreate !== undefined) {
+                await runItemCreateFileDispatch({
+                    parsed,
+                    client,
+                    multipart,
+                    ctx,
+                    programOpts: program.opts(),
+                    apiVersion,
+                    createMode,
+                    resolveBoardId,
+                    setEntries,
+                    rawEntries,
+                    m38: m38FileCreate,
+                    preflightSource: createModeResult.preflightSource,
+                    preflightCacheAgeSeconds: createModeResult.preflightCacheAgeSeconds,
+                    metaSource: m38Source,
+                    metaCacheAgeSeconds: m38CacheAge,
+                    preflightWarnings: m38Warnings,
                     dateResolution,
                     peopleResolution,
                     tagResolution,
                     relationResolution,
-                    env: ctx.env,
+                    isDryRun: globalFlags.dryRun,
                     noCache: globalFlags.noCache,
+                    retries: globalFlags.retry,
+                    toEmit,
                 });
-                // Dry-run envelope source folds three legs (Codex M9 P2 #1):
+                return;
+            }
+            if (globalFlags.dryRun) {
+                let result;
+                try {
+                    result = await planCreate({
+                        client,
+                        mode: createMode,
+                        name: parsed.name,
+                        setEntries,
+                        ...(rawEntries.length === 0 ? {} : { rawEntries }),
+                        dateResolution,
+                        peopleResolution,
+                        tagResolution,
+                        relationResolution,
+                        env: ctx.env,
+                        noCache: globalFlags.noCache,
+                    });
+                }
+                catch (err) {
+                    // Round-3 P3-1 fix: fold M38 pre-check warnings into
+                    // the failure envelope's `details.resolver_warnings`.
+                    if (err instanceof MondayCliError && m38Warnings.length > 0) {
+                        throw mergeResolverWarningsIntoError(err, m38Warnings);
+                    }
+                    throw err;
+                }
+                // Dry-run envelope source folds four legs (Codex M9 P2 #1
+                // + v0.6-M38 IMPL round-1 P3-1-equivalent fix):
                 // pre-planner network calls (parent lookup + parent-board
-                // metadata + --relative-to verification) + planCreate's
+                // metadata + --relative-to verification) + the M38
+                // pre-check's column-resolution leg + planCreate's
                 // column-resolution legs. `meta.source: "none"` is only
                 // accurate when ZERO wire calls fired.
-                const dryRunSource = mergeSourceWithPreflight(result.source, createModeResult.preflightSource);
-                const dryRunCacheAge = mergeCacheAge(result.cacheAgeSeconds, createModeResult.preflightCacheAgeSeconds);
+                const dryRunSource = mergeSourceWithPreflight(mergeSourceWithPreflight(result.source, m38Source), createModeResult.preflightSource);
+                const dryRunCacheAge = mergeCacheAge(mergeCacheAge(m38CacheAge, result.cacheAgeSeconds), createModeResult.preflightCacheAgeSeconds);
+                // Round-2 P3-1 fix: thread M38 pre-check warnings into
+                // the dry-run envelope. Pre-check's `stale_cache_refreshed`
+                // / `column_token_collision` survive even though
+                // downstream `planCreate`'s resolveAndTranslate cache-hits
+                // suppress re-emission. Dedupe inline by code+message+
+                // token (small N).
                 emitDryRun({
                     ctx,
                     programOpts: program.opts(),
                     plannedChanges: result.plannedChanges,
                     source: dryRunSource,
                     cacheAgeSeconds: dryRunCacheAge,
-                    warnings: result.warnings,
+                    warnings: dedupeCreateWarnings([...m38Warnings, ...result.warnings]),
                     apiVersion,
                 });
                 return;
             }
-            // Live create path. Three-pass resolution + translation
-            // through the shared helper (R20 lift), then bundle into one
-            // column_values map and fire the single-round-trip mutation
-            // per cli-design §5.8.
-            const resolutionResult = await resolveAndTranslate({
-                client,
-                boardId: resolveBoardId,
-                setEntries,
-                rawEntries,
-                dateResolution,
-                peopleResolution,
-                tagResolution,
-                relationResolution,
-                env: ctx.env,
-                noCache: globalFlags.noCache,
-            });
-            const collectedWarnings = [
+            // Live create path (JSON-only). Three-pass resolution +
+            // translation through the shared helper (R20 lift), then
+            // bundle into one column_values map and fire the single-
+            // round-trip mutation per cli-design §5.8. Reaching this
+            // block means the v0.7-M43 `file_create` dispatch helper
+            // did NOT apply (no file `--set` entries present) — the
+            // helper returned above; this remaining path is JSON-only
+            // single-round-trip.
+            let resolutionResult;
+            try {
+                resolutionResult = await resolveAndTranslate({
+                    client,
+                    boardId: resolveBoardId,
+                    setEntries,
+                    rawEntries,
+                    dateResolution,
+                    peopleResolution,
+                    tagResolution,
+                    relationResolution,
+                    env: ctx.env,
+                    noCache: globalFlags.noCache,
+                });
+            }
+            catch (err) {
+                // Round-3 P3-1 fix: fold M38 pre-check warnings into the
+                // live failure envelope's `details.resolver_warnings`.
+                if (err instanceof MondayCliError && m38Warnings.length > 0) {
+                    throw mergeResolverWarningsIntoError(err, m38Warnings);
+                }
+                throw err;
+            }
+            // Round-2 P3-1 fix: include M38 pre-check warnings.
+            // Deduped by code+message+token via the same shape as
+            // bulk-update's `dedupeWarnings` helper.
+            const collectedWarnings = dedupeCreateWarnings([
+                ...m38Warnings,
                 ...resolutionResult.warnings,
-            ];
+            ]);
             const resolvedIds = resolutionResult.resolvedIds;
             // Live envelope source aggregates four legs (Codex M9 P2 #1):
             // pre-planner network calls (parent lookup + parent metadata
@@ -638,6 +798,13 @@ export const itemCreateCommand = {
             // planner there can claim 'none' (no wire call); the class
             // shape only handles `EnvelopeSource = 'live'|'cache'|'mixed'`.
             const sourceAgg = new SourceAggregator();
+            // v0.6-M38 IMPL round-1 P3-1-equivalent fix: thread the M38
+            // pre-check's source/cacheAge into source aggregation so the
+            // live envelope's `meta.source` reflects the pre-check wire
+            // leg (a `live` BoardMetadata fetch when cache cold).
+            if (m38Source !== undefined) {
+                sourceAgg.record(m38Source, m38CacheAge);
+            }
             if (resolutionResult.source !== undefined) {
                 sourceAgg.record(resolutionResult.source, resolutionResult.cacheAgeSeconds);
             }
@@ -832,4 +999,394 @@ const executeCreateSubitem = async (client, inputs) => {
         response,
     };
 };
+/**
+ * Two-leg create-time file dispatch helper. Runs:
+ *
+ *   1. Single upfront {@link precheckLocalFile} on the file `--set`
+ *      raw value. Local-only; failure surfaces `usage_error` with
+ *      `details.reason: 'file_not_readable'` / `'file_empty'`
+ *      BEFORE either wire leg fires (atomicity-before-wire
+ *      discipline per cli-design §5.8).
+ *   2. Partitions `inputs.setEntries` by `token`: the entry whose
+ *      `token === inputs.m38.token` routes to leg-2; every other
+ *      entry routes to leg-1's `column_values`. `inputs.rawEntries`
+ *      route to leg-1 verbatim — `--set-raw <file-col>=<json>` is
+ *      rejected upstream at `translateRawColumnValue` per D3
+ *      permanent rejection, so by this point no raw entry targets
+ *      a file column.
+ *   3. **Dry-run branch.** Invokes {@link planCreate} on the
+ *      non-file entries (handles resolution + diff cell build),
+ *      then appends a synthetic entry-2
+ *      `operation: 'add_file_to_column'` carrying `column_id` +
+ *      `file_path` (argv-derived) + `filename` + `file_size_bytes`
+ *      from the upfront pre-check. Emits both entries together
+ *      via `emitDryRun`; no multipart wire round-trip fires.
+ *      Entry-2 omits `item_id` (the item doesn't exist yet at
+ *      dry-run time).
+ *   4. **Live branch.** `resolveAndTranslate` on the non-file
+ *      entries yields the leg-1 `column_values`; leg-1 invokes
+ *      `executeCreateItem` / `executeCreateSubitem` depending on
+ *      `inputs.createMode.kind`; leg-2 builds a
+ *      {@link FileColumnSetEntry} from the pre-check + leg-1's
+ *      new item ID and invokes {@link executeFileColumnSet}.
+ *      On full success, a single
+ *      {@link invalidateBoard} fires (mirroring M38 single-item
+ *      + M42 bulk file-dispatch invalidate timing — leg-2
+ *      mutates the file column's asset state wire-side).
+ *   5. **Leg-1 failure.** Routes through {@link foldAndRemap} to
+ *      surface `column_archived` on cache-served file-column
+ *      resolution against an archived column (mirrors the JSON
+ *      path's F4 remap above). No orphan handle because no item
+ *      was created.
+ *   6. **Leg-2 failure (orphan-warn per D1).** Catches
+ *      `MondayCliError`, applies {@link foldAndRemap} to surface
+ *      `column_archived` etc., then wraps the remapped error in
+ *      a fresh `ApiError('internal_error', ...)` carrying
+ *      `details.reason: 'create_then_file_upload_partial_failure'`
+ *      + `details.created_item_id` + `details.column_id` +
+ *      `details.cause` (JSON projection of the remapped error) +
+ *      `details.hint` (retry-leg-2-only / rollback). The board
+ *      cache is NOT invalidated on leg-2 failure — leg-1's
+ *      `create_item` doesn't affect cached board metadata
+ *      (mirrors the JSON-only create path's no-invalidate), and
+ *      leg-2 failure means no file mutation occurred wire-side.
+ */
+const runItemCreateFileDispatch = async (inputs) => {
+    // 1) Upfront local file pre-check. Atomicity-before-wire per
+    //    cli-design §5.8: pre-checks fire BEFORE any wire round-trip
+    //    so a bad path surfaces `usage_error` (exit 1) with
+    //    `details.reason: 'file_not_readable'` / `'file_empty'`
+    //    without burning either wire leg. R-v0.6-NEW-1 4th-consumer
+    //    site (M31 upload + M38 single-item + M42 file-bulk + here);
+    //    5-consumer graduation threshold not yet hit.
+    const precheck = await precheckLocalFile(inputs.m38.rawValue);
+    // 2) Partition setEntries: the file entry's `token` matches
+    //    `inputs.m38.token` (the pre-check identified it); every
+    //    other token goes to leg-1's column_values.
+    const nonFileSetEntries = inputs.setEntries.filter((e) => e.token !== inputs.m38.token);
+    // 3) Dry-run branch — D2 closure. Two `planned_changes` entries
+    //    without burning either wire leg. planCreate handles
+    //    non-file column resolution + diff cells; entry-2 is built
+    //    locally from the pre-check.
+    if (inputs.isDryRun) {
+        let planResult;
+        try {
+            planResult = await planCreate({
+                client: inputs.client,
+                mode: inputs.createMode,
+                name: inputs.parsed.name,
+                setEntries: nonFileSetEntries,
+                ...(inputs.rawEntries.length === 0
+                    ? {}
+                    : { rawEntries: inputs.rawEntries }),
+                dateResolution: inputs.dateResolution,
+                peopleResolution: inputs.peopleResolution,
+                tagResolution: inputs.tagResolution,
+                relationResolution: inputs.relationResolution,
+                env: inputs.ctx.env,
+                noCache: inputs.noCache,
+            });
+        }
+        catch (err) {
+            // Fold M38 pre-check warnings into the dry-run failure
+            // envelope's `details.resolver_warnings`. `mergeResolverWarningsIntoError`
+            // is a no-op on empty `preflightWarnings`, so no length guard
+            // is needed; the JSON path's analogous catch at
+            // `create.ts:944-951` keeps the guard inline for parity with
+            // its older pattern, but the M43 helper collapses it (smaller
+            // branch surface). Non-`MondayCliError` programmer bugs
+            // re-throw unchanged.
+            if (err instanceof MondayCliError) {
+                throw mergeResolverWarningsIntoError(err, inputs.preflightWarnings);
+            }
+            throw err;
+        }
+        // Source aggregates four legs (planner + M38 pre-check +
+        // pre-planner preflight) — mirrors the JSON-path dry-run
+        // aggregation pattern at lines 959-966 above. planCreate may
+        // return `source: 'none'` when its no-set short-circuit fires
+        // (only relevant here if the call had ONLY the file `--set`),
+        // so the standalone `mergeSourceWithPreflight` helper is used
+        // rather than the SourceAggregator class (which doesn't model
+        // 'none').
+        const dryRunSource = mergeSourceWithPreflight(mergeSourceWithPreflight(planResult.source, inputs.metaSource), inputs.preflightSource);
+        const dryRunCacheAge = mergeCacheAge(mergeCacheAge(inputs.metaCacheAgeSeconds, planResult.cacheAgeSeconds), inputs.preflightCacheAgeSeconds);
+        // Entry-2: `add_file_to_column` planned-change. Mirrors M31's
+        // dry-run shape minus `item_id` (the item doesn't exist yet).
+        // `file_path` is the argv-derived raw value per cli-design §6.4;
+        // resolved absolute path lives in pre-check rejections, not in
+        // the success-shaped dry-run envelope.
+        const fileEntry = {
+            operation: 'add_file_to_column',
+            column_id: inputs.m38.columnId,
+            file_path: inputs.m38.rawValue,
+            filename: precheck.filename,
+            file_size_bytes: precheck.fileSizeBytes,
+        };
+        const plannedChanges = [
+            ...planResult.plannedChanges,
+            fileEntry,
+        ];
+        emitDryRun({
+            ctx: inputs.ctx,
+            programOpts: inputs.programOpts,
+            plannedChanges,
+            source: dryRunSource,
+            cacheAgeSeconds: dryRunCacheAge,
+            warnings: dedupeCreateWarnings([
+                ...inputs.preflightWarnings,
+                ...planResult.warnings,
+            ]),
+            apiVersion: inputs.apiVersion,
+        });
+        return;
+    }
+    // 4) Live branch — leg-1 (create_item / create_subitem) then
+    //    leg-2 (add_file_to_column). resolveAndTranslate on non-file
+    //    entries yields leg-1's column_values; the M38 pre-check
+    //    already warmed the column-resolution cache so this leg
+    //    typically hits cache (source folds to `mixed` once leg-1
+    //    + leg-2 record `live`).
+    let resolutionResult;
+    try {
+        resolutionResult = await resolveAndTranslate({
+            client: inputs.client,
+            boardId: inputs.resolveBoardId,
+            setEntries: nonFileSetEntries,
+            rawEntries: inputs.rawEntries,
+            dateResolution: inputs.dateResolution,
+            peopleResolution: inputs.peopleResolution,
+            tagResolution: inputs.tagResolution,
+            relationResolution: inputs.relationResolution,
+            env: inputs.ctx.env,
+            noCache: inputs.noCache,
+        });
+    }
+    catch (err) {
+        // Same shape as the planCreate catch above — collapse the
+        // `&& length > 0` guard (no-op on empty) for a smaller branch
+        // surface than the JSON path's pattern at
+        // `create.ts:1010-1022`.
+        if (err instanceof MondayCliError) {
+            throw mergeResolverWarningsIntoError(err, inputs.preflightWarnings);
+        }
+        throw err;
+    }
+    // Combined warnings: M38 pre-check + resolveAndTranslate. Deduped
+    // by code+message+token (a stale_cache_refreshed seen at pre-check
+    // AND at resolveAndTranslate for the same token collapses to one
+    // entry). Mirrors the JSON path's dedupeCreateWarnings usage.
+    const collectedWarnings = dedupeCreateWarnings([...inputs.preflightWarnings, ...resolutionResult.warnings]);
+    // Source aggregator across every wire leg that fires (or that
+    // already fired upstream). Records preflight + M38 pre-check +
+    // resolveAndTranslate legs; records `'live'` once at the end of
+    // each successful wire mutation (mergeSource is idempotent for a
+    // constant `'live'` second leg so recording leg-1 + leg-2 separately
+    // is byte-equivalent to recording once).
+    const sourceAgg = new SourceAggregator();
+    // Defensive: the helper is entered only when the action body's
+    // `preCheckM38FileDispatch` returned `kind: 'file_create'`, which
+    // guarantees `metaSource` is defined (the M38 pre-check populates
+    // `source` for every entry it resolves). The `undefined` arm is
+    // unreachable from any callable test surface.
+    /* c8 ignore next 3 */
+    if (inputs.metaSource !== undefined) {
+        sourceAgg.record(inputs.metaSource, inputs.metaCacheAgeSeconds);
+    }
+    if (resolutionResult.source !== undefined) {
+        sourceAgg.record(resolutionResult.source, resolutionResult.cacheAgeSeconds);
+    }
+    if (inputs.preflightSource !== undefined) {
+        sourceAgg.record(inputs.preflightSource, inputs.preflightCacheAgeSeconds);
+    }
+    // resolved_ids — file token + non-file tokens. Mirrors §6.4
+    // mutation-envelope shape: `{ <token>: <resolved_column_id> }`
+    // for every `--set` / `--set-raw` the agent supplied.
+    const resolvedIds = {
+        [inputs.m38.token]: inputs.m38.columnId,
+        ...resolutionResult.resolvedIds,
+    };
+    // Bundle non-file translated values into leg-1's column_values
+    // parameter. `null` when zero non-file entries (mirrors the JSON
+    // path's "no `--set` values to bundle" treatment — Monday accepts
+    // `column_values: null` distinctly from an empty map).
+    const translated = resolutionResult.translated;
+    const columnValues = translated.length === 0 ? null : bundleColumnValues(translated);
+    // Leg-1: create_item or create_subitem. F4 remap on failure
+    // mirrors the JSON path's catch arm (cache-served resolution +
+    // Monday rejecting as `validation_failed` → check live archived
+    // state). No orphan handle on leg-1 failure because no item was
+    // created.
+    let leg1Result;
+    try {
+        if (inputs.createMode.kind === 'subitem') {
+            leg1Result = await executeCreateSubitem(inputs.client, {
+                parentItemId: inputs.createMode.parentItemId,
+                itemName: inputs.parsed.name,
+                columnValues,
+                createLabelsIfMissing: inputs.parsed.createLabelsIfMissing,
+            });
+        }
+        else {
+            leg1Result = await executeCreateItem(inputs.client, {
+                boardId: inputs.createMode.boardId,
+                itemName: inputs.parsed.name,
+                groupId: inputs.createMode.groupId,
+                position: inputs.createMode.position,
+                columnValues,
+                createLabelsIfMissing: inputs.parsed.createLabelsIfMissing,
+            });
+        }
+    }
+    catch (err) {
+        if (err instanceof MondayCliError) {
+            throw await foldAndRemap({
+                err,
+                warnings: collectedWarnings,
+                client: inputs.client,
+                boardId: inputs.resolveBoardId,
+                columnIds: translated.map((t) => t.columnId),
+                env: inputs.ctx.env,
+                noCache: inputs.noCache,
+                resolutionSource: resolutionResult.source ?? 'live',
+            });
+        }
+        // Defensive: every wire fetcher in `src/api/**` raises typed
+        // errors (ApiError / UsageError) which both extend MondayCliError;
+        // a non-typed throw here indicates a programmer bug in the
+        // wire layer, not a Monday-side failure that needs the F4 remap.
+        /* c8 ignore next */
+        throw err;
+    }
+    // Leg-1 fired live; record into the aggregator.
+    sourceAgg.record('live', null);
+    // Leg-2: add_file_to_column via M31's multipart fetcher. On
+    // success, build the create envelope below; on `MondayCliError`,
+    // surface the D1 orphan-warn envelope with the freshly-created
+    // item ID as the recovery handle.
+    const fileEntry = {
+        columnId: inputs.m38.columnId,
+        columnType: 'file',
+        rawValue: inputs.m38.rawValue,
+        filePath: precheck.filePath,
+        filename: precheck.filename,
+        fileSizeBytes: precheck.fileSizeBytes,
+    };
+    try {
+        await executeFileColumnSet({
+            client: inputs.client,
+            multipart: inputs.multipart,
+            itemId: leg1Result.projected.id,
+            entry: fileEntry,
+            signal: inputs.ctx.signal,
+            retries: inputs.retries,
+        });
+    }
+    catch (err) {
+        if (err instanceof MondayCliError) {
+            // foldAndRemap surfaces `column_archived` for cache-served
+            // file-column resolution against an archived column (cli-
+            // design §6.5 stable-code rule; mirrors M42's file-bulk
+            // fail-fast pattern). The remapped error's code/message
+            // surface in `details.cause` so agents can branch on
+            // leg-2's underlying outcome from the orphan-warn envelope.
+            const remapped = await foldAndRemap({
+                err,
+                warnings: collectedWarnings,
+                client: inputs.client,
+                boardId: inputs.resolveBoardId,
+                columnIds: [inputs.m38.columnId],
+                env: inputs.ctx.env,
+                noCache: inputs.noCache,
+                resolutionSource: inputs.metaSource ?? 'live',
+            });
+            // D1 orphan-warn envelope. Always-internal-error outer
+            // shape; the remapped error embeds as `details.cause` JSON
+            // projection so the agent sees `{code, message, details?}`
+            // for the underlying failure. Error.cause threads the
+            // remapped error for stack debugging in `--debug` mode.
+            const causeProjection = {
+                code: remapped.code,
+                message: remapped.message,
+            };
+            // Defensive: M31's wire-error rewraps (and foldAndRemap) always
+            // populate `details` on the returned error in practice; the
+            // undefined-arm exists only to satisfy the optional shape on
+            // the `MondayCliError` type.
+            /* c8 ignore next 3 */
+            if (remapped.details !== undefined) {
+                causeProjection.details = remapped.details;
+            }
+            const createdItemId = leg1Result.projected.id;
+            throw new ApiError('internal_error', `Item ${createdItemId} was created on board ${inputs.resolveBoardId} ` +
+                `but the file upload to column ${inputs.m38.columnId} failed ` +
+                `(${remapped.code}: ${remapped.message}). The item persists on ` +
+                `Monday; retry the file upload alone with \`monday item set ` +
+                `${createdItemId} <file-col>=<path>\` against the orphan, or roll ` +
+                `back with \`monday item delete ${createdItemId} --yes\`.`, {
+                cause: remapped,
+                details: {
+                    reason: 'create_then_file_upload_partial_failure',
+                    created_item_id: createdItemId,
+                    column_id: inputs.m38.columnId,
+                    cause: causeProjection,
+                    hint: `the item was created (id ${createdItemId}) but the file ` +
+                        `upload failed. Retry leg-2 alone with \`monday item set ` +
+                        `${createdItemId} <file-col>=<path>\`; or rollback the ` +
+                        `orphan with \`monday item delete ${createdItemId} --yes\` ` +
+                        `and re-run the original \`monday item create\` once the ` +
+                        `underlying cause is fixed.`,
+                },
+            });
+        }
+        // Non-CliError programmer bug — re-throw to the runner's catch-
+        // all (surfaces as `internal_error` whole-call). Non-typed
+        // throws indicate broken contract, not a Monday-side failure
+        // that needs the orphan-warn decoration; routing them through
+        // D1's `create_then_file_upload_partial_failure` discriminator
+        // would falsely promise an orphan-recovery path for a programmer
+        // bug.
+        /* c8 ignore next */
+        throw err;
+    }
+    // Leg-2 fired live; record into the aggregator. `'live'` + `'live'`
+    // is idempotent under mergeSource so this is the second authoritative
+    // wire-leg record (leg-1 already recorded).
+    sourceAgg.record('live', null);
+    // Both legs succeeded — single board-cache invalidate before emit
+    // (mirrors M38 single-item + M42 fail-fast file-bulk invalidate
+    // timing; leg-2 mutated the file column's asset state wire-side).
+    // The invalidate fires BEFORE emitMutation so a cache-unlink
+    // failure surfaces through the runner's catch-all rather than
+    // double-emitting after the success envelope already hit stdout.
+    await invalidateBoard(inputs.resolveBoardId, inputs.ctx.env);
+    // Map the resolver warnings into the envelope `warnings` slot.
+    const warnings = collectedWarnings;
+    // Success envelope — `data: ItemCreateOutput` from leg-1's
+    // projection. `toEmit(leg1Result.response)` threads leg-1's
+    // `complexity` + `apiVersion` slots; `sourceAgg.result()`
+    // overrides `source` + `cacheAgeSeconds` so the aggregator's
+    // result (cache + live blended across every leg) is
+    // authoritative. Leg-2's complexity is intentionally NOT folded
+    // — the contract pins leg-1's projection on `data`, and the
+    // envelope's `meta.complexity` is the create mutation's cost
+    // (multipart leg-2 has no GraphQL complexity surface).
+    // The output asset from leg-2 is attached to the item server-
+    // side; agents read it back via `monday item get <iid> --columns
+    // <file-col>` if they need the projection (the file-column
+    // dispatch's `Asset` slot is documented per item upload's
+    // envelope; the v0.7-M43 success envelope keeps the canonical
+    // ItemCreateOutput shape so JSON-path and file-path envelopes
+    // remain byte-equivalent on `data`).
+    emitMutation({
+        ctx: inputs.ctx,
+        data: leg1Result.projected,
+        schema: itemCreateOutputSchema,
+        programOpts: inputs.programOpts,
+        warnings,
+        ...inputs.toEmit(leg1Result.response),
+        ...sourceAgg.result(),
+        resolvedIds,
+    });
+};
 //# sourceMappingURL=create.js.map