@unbrained/pm-cli 2026.5.30 → 2026.6.5

package/dist/cli/commands/create.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="a9e9e59a-9be5-5285-96a5-093e23264246")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="6d06ae5b-933c-54ca-90c4-998090c1fcb3")}catch(e){}}();
 import { pathExists, removeFileIfExists, writeFileAtomic } from "../../core/fs/fs-utils.js";
 import { appendHistoryEntry, createHistoryEntry } from "../../core/history/history.js";
 import { generateItemId, normalizeItemId } from "../../core/item/id.js";
@@ -19,17 +19,17 @@ import { resolveRuntimeFieldRegistry, resolveRuntimeStatusRegistry, } from "../.
 import { EXIT_CODE, FRONT_MATTER_KEY_ORDER } from "../../core/shared/constants.js";
 import { PmCliError } from "../../core/shared/errors.js";
 import { nowIso, resolveIsoOrRelative } from "../../core/shared/time.js";
-import { getActiveExtensionRegistrations, runActiveCommandHandler, runActiveOnWriteHooks, } from "../../core/extensions/index.js";
-import { applyRegisteredItemFieldDefaultsAndValidation } from "../../core/extensions/item-fields.js";
+import { getActiveExtensionRegistrations, projectAfterCommandItemSnapshot, recordAfterCommandAffectedItem, runActiveCommandHandler, runActiveOnWriteHooks, } from "../../core/extensions/index.js";
+import { collectRegisteredItemFieldNames, applyRegisteredItemFieldDefaultsAndValidation, parseRegisteredItemFieldAssignments, } from "../../core/extensions/item-fields.js";
 import { locateItem } from "../../core/store/item-store.js";
 import { getHistoryPath, getItemPath, getSettingsPath, resolvePmRoot } from "../../core/store/paths.js";
 import { readSettings } from "../../core/store/settings.js";
 import { normalizeRiskInput, normalizeSeverityInput, parseConfidenceInput, parseRegressionInput, } from "./metadata-normalizers.js";
-import { resolveEventEndAt } from "./event-validation-messages.js";
 import { assertNoLegacyNoneToken, assertNoLegacyNoneTokens, isLegacyNoneToken } from "./legacy-none-tokens.js";
 import { parseLinkedTestAssertionEqualsMap, parseLinkedTestAssertionGteMap, parseLinkedTestBoolean, parseLinkedTestContextMode, parseLinkedTestEnvClear, parseLinkedTestEnvSet, parseLinkedTestMinLines, parseLinkedTestRegexList, parseLinkedTestStringList, } from "./linked-test-parsers.js";
 import { looksLikeStructuredLinkedTestEntry, normalizeStructuredLinkedTestEntry } from "./linked-test-entry.js";
-import { ensureEnumValue, parseEventBoolean, parseRecurrenceRule } from "./recurrence-parsers.js";
+import { ensureEnumValue } from "./recurrence-parsers.js";
+import { parseEventEntries, parseReminderEntries, parseTypeOptionEntries, } from "./repeatable-metadata-parsers.js";
 import { DEPENDENCY_KIND_VALUES, ISSUE_SEVERITY_VALUES, RISK_VALUES, SCOPE_VALUES, } from "../../types/index.js";
 const CREATE_MODE_VALUES = ["strict", "progressive"];
 const SCHEDULE_CREATE_PRESET_VALUES = ["lightweight"];
@@ -175,6 +175,22 @@ function parseStatusValue(value, statusRegistry) {
     }
     return normalized;
 }
+/**
+ * Resolve the create-time status when `--status` is omitted: a config-driven
+ * per-type `default_status` (from `pm schema add-type --default-status`) wins,
+ * then the workflow open status. An unknown configured value degrades to the
+ * open status rather than blocking the create (never-block-the-agent).
+ */
+function resolveCreateDefaultStatus(typeDefinition, statusRegistry) {
+    const configured = typeDefinition.default_status;
+    if (configured !== undefined) {
+        const normalized = normalizeStatusInput(configured, statusRegistry);
+        if (normalized) {
+            return normalized;
+        }
+    }
+    return statusRegistry.open_status;
+}
 function parseCreatedAt(value, currentIso) {
     if (!value || value.trim() === "" || value.trim().toLowerCase() === "now") {
         return currentIso;
@@ -300,11 +316,11 @@ function parseDependencies(raw, nowValue, prefix) {
     assertNoLegacyNoneTokens(raw, "--dep", "Use --clear-deps to clear dependencies.");
     const values = raw.map((entry) => {
         const trimmedEntry = entry.trim();
-        const kv = looksLikeStructuredEntry(trimmedEntry, ["id", "kind", "author", "created_at"])
+        const kv = looksLikeStructuredEntry(trimmedEntry, ["id", "kind", "type", "author", "created_at"])
             ? parseCsvKv(entry, "--dep")
             : { id: trimmedEntry, kind: "related" };
         const id = parseOptionalString(kv.id);
-        const kind = parseOptionalString(kv.kind);
+        const kind = normalizeDependencyKindInput(parseOptionalString(kv.kind ?? kv.type));
         if (!id || !kind) {
             throw new PmCliError("--dep requires id and kind, or a bare item id to create a related dependency", EXIT_CODE.USAGE);
         }
@@ -320,6 +336,18 @@ function parseDependencies(raw, nowValue, prefix) {
     });
     return { values, explicitEmpty: false };
 }
+const DEPENDENCY_KIND_INPUT_ALIASES = {
+    "blocked-by": "blocked_by",
+    depends_on: "blocked_by",
+    "depends-on": "blocked_by",
+};
+function normalizeDependencyKindInput(raw) {
+    if (typeof raw !== "string") {
+        return raw;
+    }
+    const alias = DEPENDENCY_KIND_INPUT_ALIASES[raw.toLowerCase()];
+    return alias ?? raw;
+}
 function looksLikeStructuredEntry(raw, keys) {
     if (raw.startsWith("```") || raw.includes("\n")) {
         return true;
@@ -463,77 +491,27 @@ function parseReminders(raw, nowValue) {
     if (!raw || raw.length === 0)
         return { values: undefined, explicitEmpty: false };
     assertNoLegacyNoneTokens(raw, "--reminder", "Use --clear-reminders to clear reminders.");
-    const values = raw.map((entry) => {
-        const kv = parseCsvKv(entry, "--reminder");
-        const atRaw = parseOptionalString(kv.at ?? kv.date);
-        const textRaw = parseOptionalString(kv.text ?? kv.title);
-        if (!atRaw || !textRaw) {
-            throw new PmCliError("--reminder requires at=<iso|relative> or date=<iso|relative>, plus text=<value> or title=<value>", EXIT_CODE.USAGE);
-        }
-        const text = textRaw.trim();
-        if (!text) {
-            throw new PmCliError("--reminder text must not be empty", EXIT_CODE.USAGE);
-        }
-        return {
-            at: resolveIsoOrRelative(atRaw, new Date(nowValue), "reminder.at"),
-            text,
-        };
-    });
-    return { values, explicitEmpty: false };
+    return {
+        values: parseReminderEntries(raw, new Date(nowValue), { valueMode: "raw" }),
+        explicitEmpty: false,
+    };
 }
 function parseEvents(raw, nowValue) {
     if (!raw || raw.length === 0)
         return { values: undefined, explicitEmpty: false };
     assertNoLegacyNoneTokens(raw, "--event", "Use --clear-events to clear linked events.");
-    const referenceDate = new Date(nowValue);
-    const values = raw.map((entry) => {
-        const kv = parseCsvKv(entry, "--event");
-        const startRaw = parseOptionalString(kv.start ?? kv.date)?.trim();
-        if (!startRaw) {
-            throw new PmCliError("--event requires start=<iso|relative> or date=<iso|relative>", EXIT_CODE.USAGE);
-        }
-        const startAt = resolveIsoOrRelative(startRaw, referenceDate, "event.start");
-        const endRaw = parseOptionalString(kv.end)?.trim();
-        const durationRaw = parseOptionalString(kv.duration)?.trim();
-        const endAt = resolveEventEndAt(startAt, endRaw, durationRaw, referenceDate);
-        const titleRaw = parseOptionalString(kv.title);
-        const descriptionRaw = parseOptionalString(kv.description);
-        const locationRaw = parseOptionalString(kv.location);
-        const timezoneRaw = parseOptionalString(kv.timezone);
-        const title = titleRaw?.trim();
-        const description = descriptionRaw?.trim();
-        const location = locationRaw?.trim();
-        const timezone = timezoneRaw?.trim();
-        if (titleRaw !== undefined && !title) {
-            throw new PmCliError("--event title must not be empty", EXIT_CODE.USAGE);
-        }
-        if (descriptionRaw !== undefined && !description) {
-            throw new PmCliError("--event description must not be empty", EXIT_CODE.USAGE);
-        }
-        if (locationRaw !== undefined && !location) {
-            throw new PmCliError("--event location must not be empty", EXIT_CODE.USAGE);
-        }
-        if (timezoneRaw !== undefined && !timezone) {
-            throw new PmCliError("--event timezone must not be empty", EXIT_CODE.USAGE);
-        }
-        const allDayRaw = parseOptionalString(kv.all_day)?.trim();
-        const recurrence = parseRecurrenceRule(kv, startAt, referenceDate, "defined");
-        return {
-            start_at: startAt,
-            end_at: endAt,
-            title,
-            description,
-            location,
-            all_day: allDayRaw !== undefined ? parseEventBoolean(allDayRaw, "--event all_day") : undefined,
-            timezone,
-            recurrence,
-        };
-    });
-    return { values, explicitEmpty: false };
+    return {
+        values: parseEventEntries(raw, new Date(nowValue), {
+            allDayEmptyGuard: "defined",
+            recurrenceEmptyNumericGuard: "defined",
+        }),
+        explicitEmpty: false,
+    };
 }
-function buildChangedFields(frontMatter, body, explicitUnsets) {
+function buildChangedFields(frontMatter, body, explicitUnsets, additionalFrontMatterKeys = []) {
     const changed = [
         ...FRONT_MATTER_KEY_ORDER.filter((key) => frontMatter[key] !== undefined),
+        ...additionalFrontMatterKeys.filter((key) => frontMatter[key] !== undefined),
         ...(body.length > 0 ? ["body"] : []),
         ...explicitUnsets.map((key) => `unset:${key}`),
     ];
@@ -559,44 +537,8 @@ function parseTypeOptions(raw) {
         return { values: undefined, explicitEmpty: false };
     }
     assertNoLegacyNoneTokens(raw, "--type-option", "Use --clear-type-options to clear existing type options.");
-    const values = {};
-    for (const entry of raw) {
-        const trimmedEntry = entry.trim();
-        if (trimmedEntry.length === 0) {
-            throw new PmCliError("--type-option values must not be empty", EXIT_CODE.USAGE);
-        }
-        let key;
-        let value;
-        const prefersStructuredKv = trimmedEntry.includes(",") ||
-            trimmedEntry.includes("\n") ||
-            trimmedEntry.startsWith("```") ||
-            /^(?:[-*+]\s+)?(?:key|value)\s*[:=]/i.test(trimmedEntry);
-        if (prefersStructuredKv) {
-            const kv = parseCsvKv(trimmedEntry, "--type-option");
-            key = parseOptionalString(kv.key)?.trim();
-            value = parseOptionalString(kv.value)?.trim();
-        }
-        else {
-            const equalsIndex = trimmedEntry.indexOf("=");
-            const colonIndex = trimmedEntry.indexOf(":");
-            let separatorIndex = equalsIndex;
-            if (equalsIndex <= 0 && colonIndex > 0) {
-                separatorIndex = colonIndex;
-            }
-            if (separatorIndex <= 0 || separatorIndex === trimmedEntry.length - 1) {
-                throw new PmCliError("--type-option requires key=value or key=<name>,value=<value> entries", EXIT_CODE.USAGE);
-            }
-            key = trimmedEntry.slice(0, separatorIndex).trim();
-            value = trimmedEntry.slice(separatorIndex + 1).trim();
-        }
-        if (!key || !value) {
-            throw new PmCliError("--type-option requires key and value", EXIT_CODE.USAGE);
-        }
-        values[key] = value;
-    }
-    const sortedEntries = Object.entries(values).sort((left, right) => left[0].localeCompare(right[0]));
     return {
-        values: Object.fromEntries(sortedEntries),
+        values: parseTypeOptionEntries(raw),
         explicitEmpty: false,
     };
 }
@@ -615,6 +557,7 @@ async function resolveCreateStdinInputs(options) {
         reminder: await stdinResolver.resolveList(options.reminder, "--reminder"),
         event: await stdinResolver.resolveList(options.event, "--event"),
         typeOption: await stdinResolver.resolveList(options.typeOption, "--type-option"),
+        field: await stdinResolver.resolveList(options.field, "--field"),
     };
 }
 function resolveCreateMode(createMode, defaultMode) {
@@ -711,6 +654,7 @@ function requireCreateOptionByType(typeDefinition, options, createMode, clearOpt
         reminder: options.reminder,
         event: options.event,
         typeOption: options.typeOption,
+        field: options.field,
     };
     const hasOptionValue = (optionKey) => {
         // `--add-tags` mutates the same `tags` field as `--tags`, so it must count
@@ -756,7 +700,19 @@ function requireCreateOptionByType(typeDefinition, options, createMode, clearOpt
             throw new PmCliError(`Strict create mode requires concrete values for ${requiredFlags.join(", ")}; --unset/--clear-* directives cannot satisfy required options`, EXIT_CODE.USAGE);
         }
     }
-    const missingRequiredOptions = policyState.required.filter((required) => !hasOptionValue(required));
+    // A configured per-type default_status satisfies a required `status` policy:
+    // when --status is omitted, runCreate resolves to that default (or degrades to
+    // the workflow open status), so blocking the agent for a "missing --status"
+    // would contradict the config-driven default. Scoped to status so an explicit
+    // status-required policy on a type WITHOUT a default still holds. Only the
+    // required check is relaxed; the disabled check above keeps using hasOptionValue.
+    const satisfiesRequiredOption = (optionKey) => {
+        if (optionKey === "status" && typeDefinition.default_status !== undefined) {
+            return true;
+        }
+        return hasOptionValue(optionKey);
+    };
+    const missingRequiredOptions = policyState.required.filter((required) => !satisfiesRequiredOption(required));
     return [...new Set(missingRequiredOptions.map((required) => commandOptionFlagLabel("create", required)))].sort((left, right) => left.localeCompare(right));
 }
 const MISSING_REQUIRED_TYPE_OPTION_PATTERN = /^Missing required type option "([^"]+)" for type "([^"]+)"$/;
@@ -1183,8 +1139,17 @@ export async function runCreate(options, global) {
     const events = parseEvents(resolvedOptions.event, nowValue);
     const typeOptions = parseTypeOptions(resolvedOptions.typeOption);
     const validatedTypeOptions = validateTypeOptions(type, typeOptions.values, typeRegistry);
+    const extensionRegistrations = getActiveExtensionRegistrations();
+    const extensionFieldNames = collectRegisteredItemFieldNames(extensionRegistrations);
+    const registeredItemFieldValues = parseRegisteredItemFieldAssignments(resolvedOptions.field, extensionRegistrations);
+    for (const fieldKey of Object.keys(registeredItemFieldValues)) {
+        if (!unsetTargets.frontMatterKeys.has(fieldKey)) {
+            continue;
+        }
+        throw new PmCliError(`Cannot combine --unset ${fieldKey.replaceAll("_", "-")} with --field ${fieldKey}=...`, EXIT_CODE.USAGE);
+    }
     const runtimeCreateFieldValues = collectRuntimeCreateFieldValues(resolvedOptions, runtimeFieldRegistry, type);
-    for (const fieldKey of Object.keys(runtimeCreateFieldValues.values)) {
+    for (const fieldKey of Object.keys(runtimeCreateFieldValues.values ?? {})) {
         if (!unsetTargets.frontMatterKeys.has(fieldKey)) {
             continue;
         }
@@ -1232,7 +1197,9 @@ export async function runCreate(options, global) {
         });
     }
     const id = await generateItemId(pmRoot, settings.id_prefix);
-    let status = resolvedOptions.status !== undefined ? parseStatusValue(resolvedOptions.status, statusRegistry) : statusRegistry.open_status;
+    let status = resolvedOptions.status !== undefined
+        ? parseStatusValue(resolvedOptions.status, statusRegistry)
+        : resolveCreateDefaultStatus(typeDefinition, statusRegistry);
     const priority = resolvedOptions.priority !== undefined ? ensurePriority(resolvedOptions.priority) : 2;
     // `--unset tags` clears the field; combining it with `--add-tags` is the same
     // contradiction that `--unset tags --tags ...` already rejects, so reject it
@@ -1481,10 +1448,11 @@ export async function runCreate(options, global) {
         docs: docs.values,
         reminders: reminders.values,
         events: events.values,
-        ...runtimeCreateFieldValues.values,
+        ...registeredItemFieldValues,
+        ...(runtimeCreateFieldValues.values ?? {}),
     });
     try {
-        applyRegisteredItemFieldDefaultsAndValidation(frontMatter, getActiveExtensionRegistrations());
+        applyRegisteredItemFieldDefaultsAndValidation(frontMatter, extensionRegistrations);
     }
     catch (error) {
         throw new PmCliError(error instanceof Error ? error.message : "Invalid extension item field values", EXIT_CODE.USAGE);
@@ -1492,7 +1460,7 @@ export async function runCreate(options, global) {
     const afterDocument = canonicalDocument({
         metadata: frontMatter,
         body,
-    }, { schema: settings.schema });
+    }, { schema: settings.schema, extensionFieldNames });
     const beforeDocument = {
         metadata: {},
         body: "",
@@ -1502,9 +1470,17 @@ export async function runCreate(options, global) {
     const lockRelease = await acquireLock(pmRoot, id, settings.locks.ttl_seconds, author, false, settings.governance.force_required_for_stale_lock);
     const explicitUnsetKeys = [...explicitUnsets].sort((left, right) => left.localeCompare(right));
     const historyMessage = buildHistoryMessage(resolvedOptions.message, explicitUnsetKeys);
+    const changedFields = buildChangedFields(frontMatter, body, explicitUnsetKeys, [
+        ...Object.keys(registeredItemFieldValues),
+        ...Object.keys(runtimeCreateFieldValues.values ?? {}),
+    ]);
     let hookWarnings = [];
     try {
-        await writeFileAtomic(itemPath, serializeItemDocument(afterDocument, { format: settings.item_format, schema: settings.schema }));
+        await writeFileAtomic(itemPath, serializeItemDocument(afterDocument, {
+            format: settings.item_format,
+            schema: settings.schema,
+            extensionFieldNames,
+        }));
         try {
             const entry = createHistoryEntry({
                 nowIso: nowValue,
@@ -1525,18 +1501,35 @@ export async function runCreate(options, global) {
                 path: itemPath,
                 scope: "project",
                 op: "create",
+                item_id: afterDocument.metadata.id,
+                item_type: afterDocument.metadata.type,
+                before: beforeDocument,
+                after: afterDocument,
+                changed_fields: changedFields,
             })),
             ...(await runActiveOnWriteHooks({
                 path: historyPath,
                 scope: "project",
                 op: "create:history",
+                item_id: afterDocument.metadata.id,
+                item_type: afterDocument.metadata.type,
+                before: beforeDocument,
+                after: afterDocument,
+                changed_fields: changedFields,
             })),
         ];
+        recordAfterCommandAffectedItem({
+            id: afterDocument.metadata.id,
+            op: "create",
+            item_type: afterDocument.metadata.type,
+            status: afterDocument.metadata.status,
+            current: projectAfterCommandItemSnapshot(afterDocument.metadata, changedFields),
+            changed_fields: changedFields,
+        });
     }
     finally {
         await lockRelease();
     }
-    const changedFields = buildChangedFields(frontMatter, body, explicitUnsetKeys);
     const outputItem = structuredClone(frontMatter);
     // After the create has committed (so the ID is real and shows up in the suggestion),
     // emit a single non-blocking stderr hint when the new item would be invisible on `pm
@@ -1553,4 +1546,4 @@ export async function runCreate(options, global) {
     };
 }
 //# sourceMappingURL=create.js.map
-//# debugId=a9e9e59a-9be5-5285-96a5-093e23264246
+//# debugId=6d06ae5b-933c-54ca-90c4-998090c1fcb3