monday-cli 0.7.1 → 0.8.0

package/dist/commands/item/create.js

@@ -77,13 +77,15 @@ import { buildResolutionContexts, } from '../../api/resolution-context.js';
 import { lookupItemBoard, lookupItemBoardWithHierarchy, } from '../../api/item-board-lookup.js';
 import { SourceAggregator, mergeCacheAge, mergeSourceWithPreflight, } from '../../api/source-aggregator.js';
 import { resolveAndTranslate } from '../../api/resolution-pass.js';
-import { executeFileColumnSet, preCheckM38FileDispatch, } from '../../api/file-column-set.js';
+import { executeFileColumnSet, dispatchFileLegsSequentially, preCheckM38FileDispatch, } from '../../api/file-column-set.js';
+import { addFileToColumn } from '../../api/assets.js';
 import { foldAndRemap, mergeResolverWarningsIntoError, } from '../../api/resolver-error-fold.js';
+import { projectCauseForEnvelope } from '../../api/error-decoration.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 { precheckLocalFile, isStdinFileSetSource, readStdinFileSource, resolveStdinFilename, STDIN_FILE_SENTINEL, } from '../../utils/file-source.js';
 import { invalidateBoard } from '../../api/cache.js';
 /**
  * Dedupes resolver warnings by `code + message + details.token`.
@@ -171,6 +173,73 @@ const itemCreateOutputSchema = z.object({
     group_id: z.string().nullable(),
     parent_id: ItemIdSchema.optional(),
 });
+/**
+ * v0.8-M46 create-time multi-file `--set` envelope `data` shape
+ * (D6 closure). Two-leg-group dispatch: leg-1 `create_item` (or
+ * `create_subitem`) bundling non-file `column_values`, then N
+ * sequential `add_file_to_column` legs (legs 2..N+1) against
+ * the new item ID. The envelope projects:
+ *
+ *   - `operation: 'item_create_with_files'` literal discriminator
+ *     (plural distinguishes from M43's single-file
+ *     `'item_create'` literal at `itemCreateOutputSchema`).
+ *   - Leg-1's `ItemCreateOutput` shape (item ID + name + board_id
+ *     + group_id + parent_id for subitems) inlined as `item`.
+ *   - Per-leg asset projections — one per file column that landed,
+ *     length N on success; length 0..N-1 on partial failure
+ *     (reflecting columns landed before the failing leg).
+ *   - `applied_file_columns: [<col_ids>]` echo (length 1..N on
+ *     success; length 0..N-1 on partial failure).
+ *
+ * Atomicity-envelope shape on partial failure (D2 closure):
+ * extends M43's `'create_then_file_upload_partial_failure'`
+ * discriminator at `details.reason` with always-present
+ * `details.applied_file_columns: []` slot (length 0..N-1
+ * reflecting file columns landed after leg-1 succeeded but
+ * before the failing leg). Length 0 corresponds to M43's
+ * single-file failure case; length k>0 corresponds to M46
+ * multi-file partial failure after k file legs succeeded.
+ *
+ * **Status: schema landed at v0.8-M46 pre-flight contract diff
+ * (Codex R1 P2-2 fix); runtime emit shipped at v0.8-M46 IMPL.**
+ * `runItemCreateFileMultiDispatch` (below) emits against this
+ * schema on the create-time multi-file path.
+ */
+export const itemCreateWithFilesOutputSchema = z.object({
+    operation: z.literal('item_create_with_files'),
+    item: itemCreateOutputSchema,
+    assets: z
+        .array(z
+        .object({
+        column_id: z.string().min(1),
+        filename: z.string().min(1),
+        file_size_bytes: z.number().int().nonnegative(),
+        asset: z
+            .object({
+            id: z.string().min(1),
+            name: z.string().min(1),
+        })
+            .loose(),
+    })
+        .strict())
+        .min(2),
+    applied_file_columns: z.array(z.string().min(1)).min(2),
+});
+/**
+ * Command-registry output union for `monday item create`. The JSON /
+ * single-file create paths emit the canonical `ItemCreateOutput`
+ * (v0.7-M43 deliberately kept its single-file two-leg path on the
+ * canonical shape); v0.8-M46 multi-file create emits the distinct
+ * `item_create_with_files` shape. Both are single-resource `data`
+ * payloads, so both belong in the advertised `outputSchema` union
+ * (agents discriminate on the presence of `operation` /
+ * `applied_file_columns`). Mirrors `item.update`'s union admitting
+ * its single-item file shapes.
+ */
+export const itemCreateCommandOutputSchema = z.union([
+    itemCreateOutputSchema,
+    itemCreateWithFilesOutputSchema,
+]);
 const createItemResponseSchema = z
     .object({
     id: ItemIdSchema,
@@ -199,6 +268,14 @@ const inputSchema = z
     position: positionEnum.optional(),
     relativeTo: ItemIdSchema.optional(),
     createLabelsIfMissing: z.boolean().optional(),
+    // v0.8-M47 (D7 fold): companion to a stdin file `--set
+    // <file-col>=-` source — sets Monday's wire `Asset.name` on the
+    // leg-2 `add_file_to_column`. OPTIONAL; `.min(1)` rejects an empty
+    // `--filename ""` at the parse boundary (Monday `500`s empty
+    // filenames). Default on a stdin source: `DEFAULT_STDIN_FILENAME`
+    // (`"blob"`). Consulted only on a `<file-col>=-` dispatch; ignored
+    // otherwise. See `update.ts` schema for the full rationale.
+    filename: z.string().min(1).optional(),
 })
     .strict();
 /**
@@ -460,13 +537,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.8 ` +
+                `2026-01, so depth-2 subitems have no data-model home — v0.9 ` +
                 `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.8',
+                    deferred_to: 'v0.9',
                 },
             });
         }
@@ -561,7 +638,7 @@ export const itemCreateCommand = {
     // create-or-update use `monday item upsert` (M12).
     idempotent: false,
     inputSchema,
-    outputSchema: itemCreateOutputSchema,
+    outputSchema: itemCreateCommandOutputSchema,
     attach: (program, ctx) => {
         const noun = ensureSubcommand(program, 'item', 'Item commands');
         noun
@@ -572,6 +649,7 @@ export const itemCreateCommand = {
             .option('--group <gid>', 'group ID (top-level only; default = board\'s default group)')
             .option('--set <expr>', 'repeatable <col>=<val> column write (bundled into create_item.column_values)', (value, prev) => [...prev, value], [])
             .option('--set-raw <expr>', 'repeatable <col>=<json> raw write (escape hatch — bypasses friendly translator)', (value, prev) => [...prev, value], [])
+            .option('--filename <name>', "Asset.name for a stdin file `--set <file-col>=-` source (default \"blob\")")
             .option('--parent <iid>', 'create as subitem of this parent item ID')
             .option('--position <method>', 'item placement: "before" | "after" (requires --relative-to)')
             .option('--relative-to <iid>', 'item ID for --position; must be on the same board')
@@ -629,9 +707,17 @@ export const itemCreateCommand = {
             //     entry; branches into the v0.7-M43 two-leg dispatch
             //     helper {@link runItemCreateFileDispatch} (carve-out
             //     fold from v0.6-M38's permanent rejection).
+            //   - `kind: 'file_create_multi'` — clean multi-file
+            //     `--set` entries with distinct file columns; branches
+            //     into the v0.8-M46 two-leg-group dispatch helper
+            //     `runItemCreateFileMultiDispatch` (D2 carve-out fold
+            //     from v0.6-M38's universal multi-file rejection;
+            //     runtime body shipped at v0.8-M46 IMPL).
             //   - Throws `usage_error` with
-            //     `details.reason: 'multi_file_set_unsupported'` on 2+
-            //     file `--set` entries (universal mutex rule). The
+            //     `details.reason: 'duplicate_resolved_file_columns'` when
+            //     2+ file `--set` entries resolve to the same column ID
+            //     (mirrors JSON path's cross-token duplicate-resolved-ID
+            //     contract; M46 R1 P2-1 fix). 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
@@ -643,6 +729,7 @@ export const itemCreateCommand = {
             let m38CacheAge = null;
             let m38Warnings = [];
             let m38FileCreate;
+            let m38FileCreateMulti;
             if (setEntries.length > 0) {
                 const m38 = await preCheckM38FileDispatch({
                     client,
@@ -660,6 +747,12 @@ export const itemCreateCommand = {
                 if (m38.kind === 'file_create') {
                     m38FileCreate = m38;
                 }
+                if (m38.kind === 'file_create_multi') {
+                    // v0.8-M46 D2 carve-out fold. Hold the file_create_multi
+                    // slot for the two-leg-group multi-file dispatch helper
+                    // below (runtime body shipped at v0.8-M46 IMPL).
+                    m38FileCreateMulti = m38;
+                }
             }
             // v0.6-M38 → v0.7-M43 D6 fold — branch into the two-leg
             // dispatch helper. {@link runItemCreateFileDispatch} runs
@@ -700,6 +793,42 @@ export const itemCreateCommand = {
                 });
                 return;
             }
+            // v0.8-M46 D2 carve-out fold — create-time multi-file
+            // dispatch path. argv parse + create-mode resolution + M38
+            // pre-check (which returned `kind: 'file_create_multi'`
+            // here) have already run as live contract; the two-leg-
+            // group multi-file body runs leg-1 `create_item` then N
+            // sequential `add_file_to_column` legs (runtime body
+            // shipped at v0.8-M46 IMPL).
+            if (m38FileCreateMulti !== undefined) {
+                await runItemCreateFileMultiDispatch({
+                    parsed,
+                    client,
+                    multipart,
+                    ctx,
+                    programOpts: program.opts(),
+                    apiVersion,
+                    createMode,
+                    resolveBoardId,
+                    setEntries,
+                    rawEntries,
+                    m38: m38FileCreateMulti,
+                    preflightSource: createModeResult.preflightSource,
+                    preflightCacheAgeSeconds: createModeResult.preflightCacheAgeSeconds,
+                    metaSource: m38Source,
+                    metaCacheAgeSeconds: m38CacheAge,
+                    preflightWarnings: m38Warnings,
+                    dateResolution,
+                    peopleResolution,
+                    tagResolution,
+                    relationResolution,
+                    isDryRun: globalFlags.dryRun,
+                    noCache: globalFlags.noCache,
+                    retries: globalFlags.retry,
+                    toEmit,
+                });
+                return;
+            }
             if (globalFlags.dryRun) {
                 let result;
                 try {
@@ -1052,14 +1181,21 @@ const executeCreateSubitem = async (client, inputs) => {
  *      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);
+    // 1) Resolve the file source. v0.8-M47 (D7 fold) adds the stdin
+    //    `<file-col>=-` source alongside the path source:
+    //    - path: upfront `precheckLocalFile`. Atomicity-before-wire per
+    //      cli-design §5.8 — a bad path surfaces `usage_error` (exit 1)
+    //      with `details.reason: 'file_not_readable'` / `'file_empty'`
+    //      BEFORE either wire leg; the Blob build stays deferred to
+    //      `executeFileColumnSet` after leg-1. R-v0.6-NEW-1 consumer.
+    //    - stdin: a `<file-col>=-` sentinel (scope-gated to the sole
+    //      file entry by `routeFileColumnDispatch`). The read is DEFERRED
+    //      here: dry-run must not consume stdin, and the live read fires
+    //      once BEFORE leg-1 so an empty pipe rejects without orphaning a
+    //      created item.
+    const fileSource = isStdinFileSetSource(inputs.m38.rawValue)
+        ? { kind: 'stdin', filename: resolveStdinFilename(inputs.parsed.filename) }
+        : { kind: 'path', 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.
@@ -1115,14 +1251,25 @@ const runItemCreateFileDispatch = async (inputs) => {
         // 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,
-        };
+        // the success-shaped dry-run envelope. v0.8-M47 (D4): a stdin
+        // source echoes `file_path: '-'` + `filename` but OMITS
+        // `file_size_bytes` (a stream can't be `fs.stat`'d without
+        // consuming it; additive per §6.4, so omission is non-breaking)
+        // and MUST NOT read stdin here (dry-run is a preview).
+        const fileEntry = fileSource.kind === 'stdin'
+            ? {
+                operation: 'add_file_to_column',
+                column_id: inputs.m38.columnId,
+                file_path: STDIN_FILE_SENTINEL,
+                filename: fileSource.filename,
+            }
+            : {
+                operation: 'add_file_to_column',
+                column_id: inputs.m38.columnId,
+                file_path: inputs.m38.rawValue,
+                filename: fileSource.precheck.filename,
+                file_size_bytes: fileSource.precheck.fileSizeBytes,
+            };
         const plannedChanges = [
             ...planResult.plannedChanges,
             fileEntry,
@@ -1212,6 +1359,14 @@ const runItemCreateFileDispatch = async (inputs) => {
     // `column_values: null` distinctly from an empty map).
     const translated = resolutionResult.translated;
     const columnValues = translated.length === 0 ? null : bundleColumnValues(translated);
+    // v0.8-M47: when the file source is stdin, buffer it ONCE here —
+    // BEFORE leg-1's `create_item` — so an empty / unwired pipe rejects
+    // (`usage_error`) without orphaning a created item. A path source
+    // keeps its Blob build deferred to `executeFileColumnSet` below
+    // (after leg-1) so a leg-1 failure doesn't pay for the read.
+    const stdinSource = fileSource.kind === 'stdin'
+        ? await readStdinFileSource(inputs.ctx.stdin, fileSource.filename)
+        : undefined;
     // 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
@@ -1263,24 +1418,47 @@ const runItemCreateFileDispatch = async (inputs) => {
     // 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,
-    };
+    // item ID as the recovery handle. The source diverges: a path leg
+    // builds its Blob from the pre-checked path inside
+    // `executeFileColumnSet`; a stdin leg (v0.8-M47) dispatches the
+    // Blob already buffered before leg-1 directly via `addFileToColumn`.
     try {
-        await executeFileColumnSet({
-            client: inputs.client,
-            multipart: inputs.multipart,
-            itemId: leg1Result.projected.id,
-            entry: fileEntry,
-            signal: inputs.ctx.signal,
-            retries: inputs.retries,
-        });
+        if (fileSource.kind === 'stdin') {
+            /* c8 ignore next 6 — defensive: a stdin source buffered
+               `stdinSource` before leg-1 above; the guard exists for TS
+               narrowing (kind 'stdin' ⟹ stdinSource defined). */
+            if (stdinSource === undefined) {
+                throw new ApiError('internal_error', 'runItemCreateFileDispatch: stdin source not buffered before leg-2');
+            }
+            await addFileToColumn({
+                client: inputs.client,
+                multipart: inputs.multipart,
+                itemId: leg1Result.projected.id,
+                columnId: inputs.m38.columnId,
+                file: stdinSource.blob,
+                filename: stdinSource.filename,
+                signal: inputs.ctx.signal,
+                retries: inputs.retries,
+            });
+        }
+        else {
+            const fileEntry = {
+                columnId: inputs.m38.columnId,
+                columnType: 'file',
+                rawValue: inputs.m38.rawValue,
+                filePath: fileSource.precheck.filePath,
+                filename: fileSource.precheck.filename,
+                fileSizeBytes: fileSource.precheck.fileSizeBytes,
+            };
+            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) {
@@ -1304,19 +1482,11 @@ const runItemCreateFileDispatch = async (inputs) => {
             // 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;
-            }
+            // remapped error for stack debugging in `--debug` mode. The
+            // shared `projectCauseForEnvelope` builder (R-v0.8-NEW-6) owns
+            // the `{code, message, details?}` shape; its focused unit test
+            // covers the details-absent arm this site previously c8-ignored.
+            const causeProjection = projectCauseForEnvelope(remapped);
             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 ` +
@@ -1389,4 +1559,255 @@ const runItemCreateFileDispatch = async (inputs) => {
         resolvedIds,
     });
 };
+const runItemCreateFileMultiDispatch = async (inputs) => {
+    // 1) Upfront pre-check per file path (N pre-checks, argv order;
+    //    D3). Atomicity-before-wire per cli-design §5.8 — a bad path
+    //    surfaces `usage_error` BEFORE either wire leg fires.
+    const legEntries = [];
+    for (const entry of inputs.m38.entries) {
+        const precheck = await precheckLocalFile(entry.rawValue);
+        legEntries.push({
+            columnId: entry.columnId,
+            rawValue: entry.rawValue,
+            filePath: precheck.filePath,
+            filename: precheck.filename,
+            fileSizeBytes: precheck.fileSizeBytes,
+        });
+    }
+    // 2) Partition setEntries: every file token routes to a file leg;
+    //    the rest bundle into leg-1's `create_item.column_values`.
+    const fileTokens = new Set(inputs.m38.entries.map((e) => e.token));
+    const nonFileSetEntries = inputs.setEntries.filter((e) => !fileTokens.has(e.token));
+    // 3) Dry-run branch — leg-1 planned-changes from planCreate +
+    //    N synthetic `add_file_to_column` entries (no item_id; the
+    //    item doesn't exist yet). Mirrors M43 single-file dry-run
+    //    extended to N file entries.
+    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) {
+            if (err instanceof MondayCliError) {
+                throw mergeResolverWarningsIntoError(err, inputs.preflightWarnings);
+            }
+            throw err;
+        }
+        const dryRunSource = mergeSourceWithPreflight(mergeSourceWithPreflight(planResult.source, inputs.metaSource), inputs.preflightSource);
+        const dryRunCacheAge = mergeCacheAge(mergeCacheAge(inputs.metaCacheAgeSeconds, planResult.cacheAgeSeconds), inputs.preflightCacheAgeSeconds);
+        const fileEntries = legEntries.map((leg) => ({
+            operation: 'add_file_to_column',
+            column_id: leg.columnId,
+            file_path: leg.rawValue,
+            filename: leg.filename,
+            file_size_bytes: leg.fileSizeBytes,
+        }));
+        const plannedChanges = [
+            ...planResult.plannedChanges,
+            ...fileEntries,
+        ];
+        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 with bundled
+    //    non-file column_values) then legs 2..N+1 (sequential
+    //    `add_file_to_column`).
+    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) {
+        if (err instanceof MondayCliError) {
+            throw mergeResolverWarningsIntoError(err, inputs.preflightWarnings);
+        }
+        throw err;
+    }
+    const collectedWarnings = dedupeCreateWarnings([...inputs.preflightWarnings, ...resolutionResult.warnings]);
+    const sourceAgg = new SourceAggregator();
+    /* 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 tokens + non-file tokens.
+    const resolvedIds = {
+        ...Object.fromEntries(inputs.m38.entries.map((e) => [e.token, e.columnId])),
+        ...resolutionResult.resolvedIds,
+    };
+    const translated = resolutionResult.translated;
+    const columnValues = translated.length === 0 ? null : bundleColumnValues(translated);
+    // Leg-1: create_item / create_subitem. F4 remap on failure mirrors
+    // M43 single-file leg-1; no orphan handle (no item created yet).
+    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',
+            });
+        }
+        /* c8 ignore next */
+        throw err;
+    }
+    sourceAgg.record('live', null);
+    // Legs 2..N+1: sequential `add_file_to_column` fan-out against the
+    // freshly-created item ID (R-v0.8-NEW-1 shared helper, D1 sequential
+    // within-item).
+    const createdItemId = leg1Result.projected.id;
+    const dispatch = await dispatchFileLegsSequentially({
+        client: inputs.client,
+        multipart: inputs.multipart,
+        itemId: createdItemId,
+        entries: legEntries,
+        signal: inputs.ctx.signal,
+        retries: inputs.retries,
+    });
+    if (dispatch.failure !== undefined) {
+        // Orphan-warn (D1 + D2). Extends M43's single-file discriminator
+        // `'create_then_file_upload_partial_failure'` with the always-
+        // present `applied_file_columns` slot (length 0..N-1 reflecting
+        // file columns that landed after leg-1 succeeded but before the
+        // failing file leg). foldAndRemap surfaces `column_archived` for
+        // cache-served resolution against an archived column.
+        if (dispatch.appliedColumns.length > 0) {
+            // ≥1 file leg landed wire-side — invalidate the board cache so a
+            // follow-up read doesn't serve stale asset metadata. (M43's
+            // single-file leg-2 failure never lands a file, so it skips the
+            // invalidate; the multi-file partial case can land legs.)
+            await invalidateBoard(inputs.resolveBoardId, inputs.ctx.env);
+        }
+        const remapped = await foldAndRemap({
+            err: dispatch.failure.cause,
+            warnings: collectedWarnings,
+            client: inputs.client,
+            boardId: inputs.resolveBoardId,
+            columnIds: [dispatch.failure.failedColumn],
+            env: inputs.ctx.env,
+            noCache: inputs.noCache,
+            resolutionSource: inputs.metaSource ?? 'live',
+        });
+        // Shared cause-projection builder (R-v0.8-NEW-6) — same
+        // `{code, message, details?}` shape as the M43 single-file site.
+        const causeProjection = projectCauseForEnvelope(remapped);
+        const failedColumn = dispatch.failure.failedColumn;
+        throw new ApiError('internal_error', `Item ${createdItemId} was created on board ${inputs.resolveBoardId} ` +
+            `but file upload to column ${failedColumn} failed after ` +
+            `${String(dispatch.appliedColumns.length)} of ` +
+            `${String(legEntries.length)} file column(s) landed ` +
+            `(${remapped.code}: ${remapped.message}). The item + applied file ` +
+            `columns persist on Monday; retry the unfailed columns with ` +
+            `\`monday item set ${createdItemId} <file-col>=<path>\`, or roll ` +
+            `back with \`monday item delete ${createdItemId} --yes\`.`, {
+            cause: remapped,
+            details: {
+                reason: 'create_then_file_upload_partial_failure',
+                created_item_id: createdItemId,
+                applied_file_columns: dispatch.appliedColumns,
+                failed_file_column: failedColumn,
+                column_id: failedColumn,
+                cause: causeProjection,
+                hint: `the item was created (id ${createdItemId}) and ` +
+                    `${String(dispatch.appliedColumns.length)} file column(s) ` +
+                    `landed before column ${failedColumn} failed. Retry the ` +
+                    `unfailed file columns 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.`,
+            },
+        });
+    }
+    sourceAgg.record('live', null);
+    // All N file legs succeeded — single board-cache invalidate before
+    // emit (leg-2..N+1 mutated file-column asset state wire-side).
+    await invalidateBoard(inputs.resolveBoardId, inputs.ctx.env);
+    const data = {
+        operation: 'item_create_with_files',
+        item: leg1Result.projected,
+        assets: dispatch.assets.map((a) => ({
+            column_id: a.column_id,
+            filename: a.filename,
+            file_size_bytes: a.file_size_bytes,
+            asset: a.asset,
+        })),
+        applied_file_columns: [...dispatch.appliedColumns],
+    };
+    emitMutation({
+        ctx: inputs.ctx,
+        data,
+        schema: itemCreateWithFilesOutputSchema,
+        programOpts: inputs.programOpts,
+        warnings: collectedWarnings,
+        ...inputs.toEmit(leg1Result.response),
+        ...sourceAgg.result(),
+        resolvedIds,
+    });
+};
 //# sourceMappingURL=create.js.map