@enrichlayer/el-linear 1.39.0 → 1.41.0

package/README.md

@@ -275,7 +275,11 @@ itself: `el-linear teams list --raw | jq '.[] | {key, id}'`, etc.
 [SOP-label parent gate](./docs/configuration.md#sop-label-parent-gate-validationsoplabelparentgate),
 and an opt-in
 [goal-completion gate](./docs/configuration.md#goal-completion-gate-validationgoalcompletiongate)
-(requires a falsifiable "Done when" / acceptance-criteria section).
+(requires a falsifiable "Done when" / acceptance-criteria section), plus an
+opt-in
+[intake-decision gate](./docs/configuration.md#intake-decision-gate-validationintakedecisiongate)
+that requires need, value, ownership, and placement to be decided before issue
+creation.
 el-linear can record each gate's fire/override decision to a local JSONL file so
 you can measure its **override-rate** and tell whether it's too aggressive. It is
 **off by default** and writes nothing unless you opt in (e.g.

package/claude-skills/linear-operations/SKILL.md

@@ -447,7 +447,7 @@ Run `el-linear usage` for the full command reference. Non-obvious rules:
 - **Subcommand aliases** — `read`/`view`/`get`/`show`, `update`/`edit`/`set`.
 - **`--jq` for GraphQL filtering** — never pipe through `jq` directly (zsh escaping breaks `!=`).
 - **`--raw` flag** strips the `{ data, meta }` wrapper — emits just the array.
-- **Body/description from a file** — `issues create`/`update` take `--description-file <path>`; `comments create`/`update` take `--body-file <path>`. Prefer the file form for any body with backticks, fenced code, or markdown tables — it sidesteps shell-quoting traps (the same reason `el-git mr comment --body-file` exists). `--body` and `--body-file` are **mutually exclusive** (passing both errors); file-sourced bodies get the same auto-link / auto-mention treatment as inline `--body`.
+- **Body/description/content from a file** — `issues create`/`update` take `--description-file <path>`; `comments create`/`update` take `--body-file <path>`; **`projects create`/`update` take `--content-file <path>`** (the project's full markdown **content**, not its short `description` — see the two-field gotcha under *Project Management Gotchas*). Prefer the file form for any body with backticks, fenced code, or markdown tables — it sidesteps shell-quoting traps (the same reason `el-git mr comment --body-file` exists). The inline and file flags are **mutually exclusive** (passing both errors); file-sourced bodies get the same auto-link / auto-mention treatment as inline text.
 
 ### Output format
 

package/dist/commands/issues/description.d.ts

@@ -23,6 +23,9 @@ import type { LinearService } from "../../utils/linear-service.js";
 /**
  * Read description from a file path or stdin ("-").
  * Avoids shell escaping issues when descriptions contain special characters.
+ *
+ * Delegates to the shared reader so `projects --content-file` (DEV-6033), which
+ * is specified to behave identically, cannot drift from this one.
  */
 export declare function readDescriptionFile(filePath: string): string;
 /**

package/dist/commands/issues/description.js

@@ -16,27 +16,24 @@
  * Extracted from `commands/issues.ts` (ALL-938) so that file can
  * focus on commander wiring + handlers.
  */
-import fs from "node:fs";
 import { loadConfig } from "../../config/config.js";
 import { UPDATE_ISSUE_MUTATION } from "../../queries/issues.js";
 import { autoLinkReferences, } from "../../utils/auto-link-references.js";
 import { normalizeInlineTextInput } from "../../utils/inline-text-input.js";
 import { extractIssueReferences } from "../../utils/issue-reference-extractor.js";
 import { wrapIssueReferencesAsLinks } from "../../utils/issue-reference-wrapper.js";
+import { readTextInputFile } from "../../utils/text-input-file.js";
 import { validateReferences } from "../../utils/validate-references.js";
 import { getWorkspaceUrlKey } from "../../utils/workspace-url.js";
 /**
  * Read description from a file path or stdin ("-").
  * Avoids shell escaping issues when descriptions contain special characters.
+ *
+ * Delegates to the shared reader so `projects --content-file` (DEV-6033), which
+ * is specified to behave identically, cannot drift from this one.
  */
 export function readDescriptionFile(filePath) {
-    if (filePath === "-") {
-        return fs.readFileSync(0, "utf8").trim();
-    }
-    if (!fs.existsSync(filePath)) {
-        throw new Error(`Description file not found: ${filePath}`);
-    }
-    return fs.readFileSync(filePath, "utf8").trim();
+    return readTextInputFile(filePath, "Description");
 }
 /**
  * Resolve the description from --description, --description-file, or

package/dist/commands/issues.js

@@ -2,6 +2,7 @@ import { execFileSync } from "node:child_process";
 import { loadConfig } from "../config/config.js";
 import { enrichProjectResolverError, enrichValidationErrors, } from "../config/error-enrichment.js";
 import { evaluateGoalCompletion, formatGoalCompletionBlock, getGoalCompletionGateConfig, } from "../config/goal-completion-validation.js";
+import { evaluateIntakeDecision, formatIntakeDecisionBlock, getIntakeDecisionGateConfig, } from "../config/intake-decision-validation.js";
 import { enforceValidation, validateIssueCreation, } from "../config/issue-validation.js";
 import { resolveAssignee, resolveLabels, resolveMemberWithRegistry, resolveTeam, } from "../config/resolver.js";
 import { formatSopParentBlock, getSopLabelGateConfig, hasSopLabel, isUnresolvableReferenceError, } from "../config/sop-label-validation.js";
@@ -762,6 +763,43 @@ async function enforceGoalCompletion(description, options) {
     });
     throw new Error(`Issue creation blocked: ${message}`);
 }
+/**
+ * DEV-6163: require the intake judgment before any create-time resolution or
+ * mutation. Unlike general field validation, this gate is not silently
+ * bypassed by `--skip-validation`; only its narrow, recorded override applies.
+ */
+async function enforceIntakeDecision(description, options) {
+    const { mode, headers } = getIntakeDecisionGateConfig();
+    if (mode === "off") {
+        return;
+    }
+    const evaluation = evaluateIntakeDecision(description, headers);
+    if (evaluation.ok) {
+        return;
+    }
+    const gateEvent = { gate: "issues-create-intake-decision" };
+    if (options.allowMissingIntakeDecision) {
+        await emitGateEvent("el-linear", "issues create", {
+            ...gateEvent,
+            outcome: "overridden",
+        });
+        return;
+    }
+    const message = formatIntakeDecisionBlock({ evaluation, headers });
+    if (mode === "warn") {
+        await emitGateEvent("el-linear", "issues create", {
+            ...gateEvent,
+            outcome: "advisory",
+        });
+        outputWarning(message);
+        return;
+    }
+    await emitGateEvent("el-linear", "issues create", {
+        ...gateEvent,
+        outcome: "blocked",
+    });
+    throw new Error(`Issue creation blocked: ${message}`);
+}
 async function handleCreateIssue(title, options, command) {
     const rootOpts = getRootOpts(command);
     // DEV-5920 (cycle-2): resolve the description exactly ONCE, before anything
@@ -779,6 +817,7 @@ async function handleCreateIssue(title, options, command) {
     // normalization) — re-resolving an inline copy would corrupt a file that
     // intentionally contains backslash sequences.
     const rawDescription = resolveDescription(options);
+    await enforceIntakeDecision(rawDescription ?? "", options);
     const { teamInput, teamId, assigneeId, delegateId, labelIds, status, subscriberIds, priority, } = await resolveCreateInputs(title ?? "", options, rootOpts, rawDescription);
     const uploadResults = await uploadAttachmentsIfNeeded(options, rootOpts);
     const descriptionWithAttachments = buildDescriptionWithAttachments(rawDescription ?? "", uploadResults);
@@ -1401,10 +1440,11 @@ export function setupIssuesCommands(program) {
         .option("--due-date <date>", "due date (YYYY-MM-DD)")
         .option("--checkout", "create and checkout a git branch named after the issue")
         .option("--no-claim", "with --checkout, skip assigning the issue to the current Linear user and moving it to the first started state")
-        .option("--skip-validation", "skip all validation (labels, description, assignee, project, duplicate detection, SOP-parent gate, goal-completion gate)")
+        .option("--skip-validation", "skip general validation (labels, description, assignee, project, duplicate detection, SOP-parent gate, goal-completion gate); the intake-decision gate still requires its narrow override")
         .option("--allow-duplicate", "silence the duplicate-detection hard block and create even if a near-identical issue already exists (DEV-5590: only matters at/above the hard-block threshold — below it the gate is advisory-only and never blocks)")
         .option("--allow-unparented-sop", "skip the SOP-label parent gate and create an SOP-labeled issue without a parent SOP")
         .option("--allow-vague-goal", 'skip the goal-completion gate and create even without a falsifiable "Done when" / acceptance-criteria section')
+        .option("--allow-missing-intake-decision", "create without a complete intake decision when an accountable human approved the exception (recorded as a gate override)")
         .option("--no-auto-link", "skip auto-linking issue references found in the description")
         .option("--footer <text>", "text appended to the description (overrides config.messageFooter)")
         .option("--no-footer", "skip the configured messageFooter for this issue")

package/dist/commands/projects.d.ts

@@ -5,4 +5,28 @@ export declare function resolveProjectStateFilter(options: OptionValues): {
     states?: string[];
     excludeStates?: string[];
 };
+/**
+ * Resolve the project body from `--content <markdown>` or `--content-file <path>`
+ * (DEV-6033). The two are sources for the same field, so accepting both would
+ * silently drop one — we REJECT up front instead.
+ *
+ * That matches `comments --body-file` and `project-updates --body-file`, and it
+ * deliberately DIVERGES from `issues --description-file`, which documents a
+ * precedence (`--description-file` > `--description`) and therefore lets the file
+ * silently win when both are passed. Rejecting is the better contract — a caller
+ * who passes both has a bug, and telling them beats guessing — but do not describe
+ * this as "mirroring" issues: it is not, and a false claim about a sibling's
+ * mechanism outlives the person who wrote it.
+ *
+ * Returns `undefined` only when NEITHER flag was passed, which is what lets
+ * `projects update` keep distinguishing "leave content alone" from "clear it"
+ * (`--content ""` yields `""`, and `"" !== undefined`, so it still reaches the
+ * mutation — the same distinction `hasOption` drew before).
+ *
+ * Inline `--content` is passed through verbatim, exactly as it was before this
+ * flag existed. It is deliberately NOT run through `normalizeInlineTextInput`:
+ * that would newly rewrite `\n` inside an existing caller's `--content` string,
+ * a behavior change to a shipped flag that this issue does not ask for.
+ */
+export declare function resolveProjectContent(options: OptionValues): string | undefined;
 export declare function setupProjectsCommands(program: Command): void;

package/dist/commands/projects.js

@@ -8,6 +8,7 @@ import { logger } from "../utils/logger.js";
 import { handleAsyncCommand, outputSuccess, outputWarning, } from "../utils/output.js";
 import { effectiveOption, getRootOpts } from "../utils/root-opts.js";
 import { renderCsv, renderFixedWidthTable, renderMarkdownTable, } from "../utils/table-formatter.js";
+import { readTextInputFile } from "../utils/text-input-file.js";
 import { isUuid } from "../utils/uuid.js";
 import { parsePositiveInt, splitList } from "../utils/validators.js";
 const VALID_PROJECT_STATES = new Set([
@@ -232,6 +233,43 @@ function formatTeamsOutput(projectUpdate) {
 function hasOption(options, key) {
     return options[key] !== undefined;
 }
+/**
+ * Resolve the project body from `--content <markdown>` or `--content-file <path>`
+ * (DEV-6033). The two are sources for the same field, so accepting both would
+ * silently drop one — we REJECT up front instead.
+ *
+ * That matches `comments --body-file` and `project-updates --body-file`, and it
+ * deliberately DIVERGES from `issues --description-file`, which documents a
+ * precedence (`--description-file` > `--description`) and therefore lets the file
+ * silently win when both are passed. Rejecting is the better contract — a caller
+ * who passes both has a bug, and telling them beats guessing — but do not describe
+ * this as "mirroring" issues: it is not, and a false claim about a sibling's
+ * mechanism outlives the person who wrote it.
+ *
+ * Returns `undefined` only when NEITHER flag was passed, which is what lets
+ * `projects update` keep distinguishing "leave content alone" from "clear it"
+ * (`--content ""` yields `""`, and `"" !== undefined`, so it still reaches the
+ * mutation — the same distinction `hasOption` drew before).
+ *
+ * Inline `--content` is passed through verbatim, exactly as it was before this
+ * flag existed. It is deliberately NOT run through `normalizeInlineTextInput`:
+ * that would newly rewrite `\n` inside an existing caller's `--content` string,
+ * a behavior change to a shipped flag that this issue does not ask for.
+ */
+export function resolveProjectContent(options) {
+    const hasInline = typeof options.content === "string";
+    const hasFile = typeof options.contentFile === "string";
+    if (hasInline && hasFile) {
+        throw new Error("--content and --content-file are mutually exclusive — pass one or the other");
+    }
+    if (hasFile) {
+        return readTextInputFile(options.contentFile, "Content");
+    }
+    if (hasInline) {
+        return options.content;
+    }
+    return undefined;
+}
 function flattenProjectUpdate(projectUpdate) {
     if (!projectUpdate.project) {
         throw new Error("Failed to update project");
@@ -345,6 +383,11 @@ async function handleRemoveTeam(projectNameOrId, teamInput, options, command) {
     });
 }
 async function handleCreateProject(name, options, command) {
+    // Resolve the body BEFORE the create mutation. An unreadable --content-file
+    // (or --content alongside it) must fail while nothing has been created yet —
+    // resolving after the create would leave an orphan project behind and then
+    // throw, which is the worst of both outcomes.
+    const content = resolveProjectContent(options);
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
     // Step 1: Check for duplicate projects (case-insensitive)
@@ -376,10 +419,10 @@ async function handleCreateProject(name, options, command) {
     }
     const project = createResult.projectCreate.project;
     // Step 4: Set content if provided (separate mutation — Linear API quirk)
-    if (options.content) {
+    if (content) {
         await graphQLService.rawRequest(UPDATE_PROJECT_MUTATION, {
             id: project.id,
-            input: { content: options.content },
+            input: { content },
         });
     }
     const teamList = project.teams.nodes.map((t) => t.key).join(", ");
@@ -465,11 +508,15 @@ async function handleUpdateProject(projectNameOrId, options, command) {
     if (hasOption(options, "description")) {
         input.description = options.description;
     }
-    if (hasOption(options, "content")) {
-        input.content = options.content;
+    // `undefined` means neither --content nor --content-file was passed. An
+    // explicit `--content ""` resolves to "" and still lands here, so clearing a
+    // project's body keeps working exactly as it did under `hasOption`.
+    const content = resolveProjectContent(options);
+    if (content !== undefined) {
+        input.content = content;
     }
     if (Object.keys(input).length === 0) {
-        throw new Error("Nothing to update. Pass at least one of --name, --description, or --content.");
+        throw new Error("Nothing to update. Pass at least one of --name, --description, --content, or --content-file.");
     }
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
@@ -494,6 +541,7 @@ export function setupProjectsCommands(program) {
         .option("--team <teams>", "comma-separated team keys (e.g., FE,DEV)")
         .option("-d, --description <text>", "short summary (max 255 chars, shown in lists)")
         .option("--content <markdown>", "full markdown body (shown in project panel)")
+        .option("--content-file <path>", "read the markdown body from a file (or '-' for stdin); mutually exclusive with --content")
         .option("--force", "create even if a project with the same name exists")
         .action(handleAsyncCommand(handleCreateProject));
     projects
@@ -514,6 +562,7 @@ export function setupProjectsCommands(program) {
         .option("--name <name>", "project name")
         .option("-d, --description <text>", "short summary (max 255 chars, shown in lists)")
         .option("--content <markdown>", "full markdown body (shown in project panel)")
+        .option("--content-file <path>", "read the markdown body from a file (or '-' for stdin); mutually exclusive with --content")
         .action(handleAsyncCommand(handleUpdateProject));
     projects
         .command("list")

package/dist/config/config.d.ts

@@ -115,6 +115,18 @@ export interface ElLinearConfig {
          * "Acceptance criteria", "Success criteria"]`.
          */
         goalSectionHeaders?: string[];
+        /**
+         * OPT-IN explicit intake gate (DEV-6163). When `"warn"` or `"block"`,
+         * `issues create` requires an ordered `Intake decision` section recording
+         * why the work is needed, why it is worth doing, the existing/duplicate
+         * work checked, its canonical owner, concrete placement, and a `PROCEED`
+         * decision. Defaults to off for the
+         * open-source package. A narrow, recorded override is available through
+         * `--allow-missing-intake-decision`.
+         */
+        intakeDecisionGate?: false | "warn" | "block";
+        /** Headers accepted for the intake section. Defaults to `["Intake decision"]`. */
+        intakeSectionHeaders?: string[];
     };
     /**
      * Optional override for the Linear workspace URL key (the part after

package/dist/config/intake-decision-validation.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Explicit issue-intake validation — DEV-6163.
+ *
+ * This gate does not try to decide whether work is worthwhile or where it
+ * belongs. It requires the author to record those judgments, in order, before
+ * `issues create` can mutate Linear. The deterministic part is completeness:
+ * needed, worth doing, existing/duplicate work checked, canonical owner,
+ * concrete placement, then a proceed decision.
+ *
+ * OPT-IN by design. el-linear is open source, so the gate is dormant unless a
+ * workspace config sets `validation.intakeDecisionGate` to `"warn"` or
+ * `"block"`.
+ */
+export declare const DEFAULT_INTAKE_SECTION_HEADERS: string[];
+export type IntakeDecisionGateMode = "off" | "warn" | "block";
+export interface IntakeDecisionGateConfig {
+    mode: IntakeDecisionGateMode;
+    headers: string[];
+}
+export declare function getIntakeDecisionGateConfig(): IntakeDecisionGateConfig;
+export type IntakeDecisionEvaluation = {
+    ok: true;
+    header: string;
+} | {
+    ok: false;
+    reason: "no-section";
+} | {
+    ok: false;
+    reason: "missing-field";
+    field: string;
+} | {
+    ok: false;
+    reason: "duplicate-field";
+    field: string;
+} | {
+    ok: false;
+    reason: "out-of-order";
+    field: string;
+} | {
+    ok: false;
+    reason: "invalid-field";
+    field: string;
+} | {
+    ok: false;
+    reason: "not-proceeding";
+    decision: string;
+};
+export declare function evaluateIntakeDecision(description: string, headers?: string[]): IntakeDecisionEvaluation;
+export declare function formatIntakeDecisionBlock(opts: {
+    evaluation: Exclude<IntakeDecisionEvaluation, {
+        ok: true;
+    }>;
+    headers: string[];
+}): string;

package/dist/config/intake-decision-validation.js

@@ -0,0 +1,161 @@
+/**
+ * Explicit issue-intake validation — DEV-6163.
+ *
+ * This gate does not try to decide whether work is worthwhile or where it
+ * belongs. It requires the author to record those judgments, in order, before
+ * `issues create` can mutate Linear. The deterministic part is completeness:
+ * needed, worth doing, existing/duplicate work checked, canonical owner,
+ * concrete placement, then a proceed decision.
+ *
+ * OPT-IN by design. el-linear is open source, so the gate is dormant unless a
+ * workspace config sets `validation.intakeDecisionGate` to `"warn"` or
+ * `"block"`.
+ */
+import { extractField, stripFencedCodeBlocks } from "../utils/extract-field.js";
+import { loadConfig } from "./config.js";
+export const DEFAULT_INTAKE_SECTION_HEADERS = ["Intake decision"];
+export function getIntakeDecisionGateConfig() {
+    const validation = loadConfig().validation;
+    const raw = validation?.intakeDecisionGate;
+    const mode = validation?.enabled !== false && (raw === "warn" || raw === "block")
+        ? raw
+        : "off";
+    const headers = validation?.intakeSectionHeaders &&
+        validation.intakeSectionHeaders.length > 0
+        ? validation.intakeSectionHeaders
+        : DEFAULT_INTAKE_SECTION_HEADERS;
+    return { mode, headers };
+}
+const FIELD_DEFINITIONS = [
+    { key: "needed", label: "Needed" },
+    { key: "worth", label: "Worth doing" },
+    { key: "existing", label: "Existing work" },
+    { key: "owner", label: "Owner" },
+    { key: "placement", label: "Placement" },
+    { key: "decision", label: "Decision" },
+];
+const FIELD_LINE = /^\s*(?:[-*+]\s+|\d+[.)]\s+)?(?:\*\*)?(Needed|Worth doing|Existing work|Owner|Placement|Decision)(?:\*\*)?\s*:\s*(.*?)\s*$/gim;
+const PLACEHOLDER = /^(?:tbd|todo|unknown|n\/?a|none|unsure|not decided|-)\.?$/i;
+const NON_SPECIFIC = /^(?:yes|no)$/i;
+const AFFIRMATIVE_WITH_REASON = /^yes\s*(?:[-—:;,]|because)\s*(\S.{2,})$/i;
+function normalizedKey(label) {
+    switch (label.toLowerCase()) {
+        case "needed":
+            return "needed";
+        case "worth doing":
+            return "worth";
+        case "existing work":
+            return "existing";
+        case "owner":
+            return "owner";
+        case "placement":
+            return "placement";
+        default:
+            return "decision";
+    }
+}
+export function evaluateIntakeDecision(description, headers = DEFAULT_INTAKE_SECTION_HEADERS) {
+    let section = null;
+    let matchedHeader = "";
+    for (const header of headers) {
+        section = extractField(description, header);
+        if (section !== null) {
+            matchedHeader = header;
+            break;
+        }
+    }
+    if (section === null) {
+        return { ok: false, reason: "no-section" };
+    }
+    // A template/example fence is not an operative decision record. Remove all
+    // fenced examples before matching so copied guidance cannot satisfy intake.
+    const operativeSection = stripFencedCodeBlocks(section);
+    const values = new Map();
+    for (const match of operativeSection.matchAll(FIELD_LINE)) {
+        const key = normalizedKey(match[1] ?? "");
+        if (values.has(key)) {
+            return {
+                ok: false,
+                reason: "duplicate-field",
+                field: FIELD_DEFINITIONS.find((field) => field.key === key)?.label ?? key,
+            };
+        }
+        values.set(key, { value: match[2]?.trim() ?? "", index: match.index });
+    }
+    let previousIndex = -1;
+    for (const definition of FIELD_DEFINITIONS) {
+        const entry = values.get(definition.key);
+        if (!entry) {
+            return {
+                ok: false,
+                reason: "missing-field",
+                field: definition.label,
+            };
+        }
+        if (entry.index < previousIndex) {
+            return {
+                ok: false,
+                reason: "out-of-order",
+                field: definition.label,
+            };
+        }
+        previousIndex = entry.index;
+    }
+    for (const key of ["needed", "worth"]) {
+        const value = values.get(key)?.value ?? "";
+        const match = value.match(AFFIRMATIVE_WITH_REASON);
+        const reason = match?.[1]?.trim() ?? "";
+        if (!match || PLACEHOLDER.test(reason)) {
+            return {
+                ok: false,
+                reason: "invalid-field",
+                field: key === "needed" ? "Needed" : "Worth doing",
+            };
+        }
+    }
+    for (const key of ["existing", "owner", "placement"]) {
+        const value = values.get(key)?.value ?? "";
+        if (value.length < 3 ||
+            PLACEHOLDER.test(value) ||
+            NON_SPECIFIC.test(value)) {
+            return {
+                ok: false,
+                reason: "invalid-field",
+                field: key === "existing"
+                    ? "Existing work"
+                    : key === "owner"
+                        ? "Owner"
+                        : "Placement",
+            };
+        }
+    }
+    const decision = values.get("decision")?.value ?? "";
+    if (!/^proceed$/i.test(decision)) {
+        return { ok: false, reason: "not-proceeding", decision };
+    }
+    return { ok: true, header: matchedHeader };
+}
+export function formatIntakeDecisionBlock(opts) {
+    const { evaluation } = opts;
+    let reason;
+    switch (evaluation.reason) {
+        case "no-section":
+            reason = `Issue description has no intake section (looked for: ${opts.headers.join(", ")}).`;
+            break;
+        case "missing-field":
+            reason = `The intake decision is missing the "${evaluation.field}" field.`;
+            break;
+        case "duplicate-field":
+            reason = `The intake decision repeats the "${evaluation.field}" field; record one unambiguous value.`;
+            break;
+        case "out-of-order":
+            reason = `The intake fields are out of order at "${evaluation.field}".`;
+            break;
+        case "invalid-field":
+            reason = `The intake field "${evaluation.field}" is empty, a placeholder, or lacks an explicit yes-and-reason judgment.`;
+            break;
+        case "not-proceeding":
+            reason = `The intake decision is "${evaluation.decision || "empty"}", not PROCEED.`;
+    }
+    return `${reason}\n\nRecord the decision before creating the issue, in this exact order:\n\n## ${opts.headers[0]}\n- Needed: Yes — <why this is needed>\n- Worth doing: Yes — <why the value exceeds the cost>\n- Existing work: <duplicate/search result and evidence>\n- Owner: <canonical owner or source of truth>\n- Placement: <team/project/repository/document path>\n- Decision: PROCEED\n\nIf an accountable human has approved an exceptional create, re-run with --allow-missing-intake-decision; that override is recorded.`;
+}

package/dist/utils/extract-field.d.ts

@@ -16,6 +16,8 @@
  * Returns `null` when the field isn't found, so callers can distinguish
  * "missing" from "empty body".
  */
+/** Remove operative text inside CommonMark fenced code blocks, including an unclosed block through EOF. */
+export declare function stripFencedCodeBlocks(body: string): string;
 /**
  * Multi-section variant of `extractField`. Extracts each requested section
  * by name in one call and returns a `{section -> text|null}` map preserving

package/dist/utils/extract-field.js

@@ -28,7 +28,50 @@ const BOLD_PSEUDO_HEADER_RE = /^\*\*([^*\n]+?)(?::\s*)?\*\*\s*$/;
 // permitted as fence indent per the CommonMark spec). We toggle an inFence
 // flag while scanning so section headers inside code samples don't
 // terminate the real section.
-const FENCE_RE = /^ {0,3}(`{3,}|~{3,})/;
+const FENCE_DELIMITER_RE = /^ {0,3}(`{3,}|~{3,})(.*)$/;
+function fenceDelimiter(line) {
+    const match = line.match(FENCE_DELIMITER_RE);
+    const run = match?.[1] ?? "";
+    if (!run || new Set(run).size !== 1)
+        return null;
+    return { run, rest: match?.[2] ?? "" };
+}
+function openFence(line) {
+    const delimiter = fenceDelimiter(line);
+    if (!delimiter)
+        return null;
+    const marker = delimiter.run[0];
+    // CommonMark forbids backticks in the info string of a backtick fence.
+    if (marker === "`" && delimiter.rest.includes("`"))
+        return null;
+    return { marker, length: delimiter.run.length };
+}
+function closesFence(line, state) {
+    const delimiter = fenceDelimiter(line);
+    return (delimiter !== null &&
+        delimiter.run[0] === state.marker &&
+        delimiter.run.length >= state.length &&
+        delimiter.rest.trim().length === 0);
+}
+/** Remove operative text inside CommonMark fenced code blocks, including an unclosed block through EOF. */
+export function stripFencedCodeBlocks(body) {
+    const out = [];
+    let fence = null;
+    for (const line of body.split("\n")) {
+        if (fence) {
+            if (closesFence(line, fence))
+                fence = null;
+            continue;
+        }
+        const opened = openFence(line);
+        if (opened) {
+            fence = opened;
+            continue;
+        }
+        out.push(line);
+    }
+    return out.join("\n");
+}
 function normalize(s) {
     return s.toLowerCase().trim().replace(/\s+/g, " ");
 }
@@ -86,15 +129,19 @@ export function extractField(body, fieldName) {
         return null;
     const target = normalize(fieldName);
     const lines = body.split("\n");
-    let inFence = false;
+    let fence = null;
     let startIdx = -1;
     for (let i = 0; i < lines.length; i++) {
-        if (FENCE_RE.test(lines[i])) {
-            inFence = !inFence;
+        if (fence) {
+            if (closesFence(lines[i], fence))
+                fence = null;
             continue;
         }
-        if (inFence)
+        const opened = openFence(lines[i]);
+        if (opened) {
+            fence = opened;
             continue;
+        }
         const match = matchHeader(lines[i]);
         if (!match)
             continue;
@@ -106,14 +153,21 @@ export function extractField(body, fieldName) {
     if (startIdx === -1)
         return null;
     const out = [];
-    let sectionInFence = false;
+    let sectionFence = null;
     for (let i = startIdx; i < lines.length; i++) {
-        if (FENCE_RE.test(lines[i])) {
-            sectionInFence = !sectionInFence;
+        if (sectionFence) {
+            if (closesFence(lines[i], sectionFence))
+                sectionFence = null;
+            out.push(lines[i]);
+            continue;
+        }
+        const opened = openFence(lines[i]);
+        if (opened) {
+            sectionFence = opened;
             out.push(lines[i]);
             continue;
         }
-        if (!sectionInFence && matchHeader(lines[i]) !== null)
+        if (matchHeader(lines[i]) !== null)
             break;
         out.push(lines[i]);
     }

package/dist/utils/text-input-file.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Read the body for a `--*-file` flag: a path on disk, or `-` for stdin.
+ *
+ * These flags exist to keep large markdown bodies away from the shell. The
+ * workaround they replace — `--content "$(cat body.md)"` — hands the file's
+ * bytes to the shell first, so backticks, `$`, and nested quotes inside the
+ * markdown get interpolated before the CLI ever sees them. Reading the path
+ * ourselves means the bytes arrive exactly as authored.
+ *
+ * For the same reason the content is used verbatim: no escape-sequence
+ * normalization. That is `normalizeInlineTextInput`'s job for the *inline*
+ * flags, where a user typing `\n` at a shell prompt means a newline. In a file,
+ * a literal `\n` inside a fenced code block is content, and rewriting it would
+ * corrupt the document.
+ *
+ * `label` names the subject in the not-found error, so each flag reports itself
+ * ("Description file not found: …", "Content file not found: …").
+ *
+ * Single source of truth for `issues --description-file` and `projects
+ * --content-file` (DEV-6033) — the two are specified to behave identically, so
+ * they share one implementation rather than two that drift.
+ */
+export declare function readTextInputFile(filePath: string, label: string): string;

package/dist/utils/text-input-file.js

@@ -0,0 +1,32 @@
+import fs from "node:fs";
+/**
+ * Read the body for a `--*-file` flag: a path on disk, or `-` for stdin.
+ *
+ * These flags exist to keep large markdown bodies away from the shell. The
+ * workaround they replace — `--content "$(cat body.md)"` — hands the file's
+ * bytes to the shell first, so backticks, `$`, and nested quotes inside the
+ * markdown get interpolated before the CLI ever sees them. Reading the path
+ * ourselves means the bytes arrive exactly as authored.
+ *
+ * For the same reason the content is used verbatim: no escape-sequence
+ * normalization. That is `normalizeInlineTextInput`'s job for the *inline*
+ * flags, where a user typing `\n` at a shell prompt means a newline. In a file,
+ * a literal `\n` inside a fenced code block is content, and rewriting it would
+ * corrupt the document.
+ *
+ * `label` names the subject in the not-found error, so each flag reports itself
+ * ("Description file not found: …", "Content file not found: …").
+ *
+ * Single source of truth for `issues --description-file` and `projects
+ * --content-file` (DEV-6033) — the two are specified to behave identically, so
+ * they share one implementation rather than two that drift.
+ */
+export function readTextInputFile(filePath, label) {
+    if (filePath === "-") {
+        return fs.readFileSync(0, "utf8").trim();
+    }
+    if (!fs.existsSync(filePath)) {
+        throw new Error(`${label} file not found: ${filePath}`);
+    }
+    return fs.readFileSync(filePath, "utf8").trim();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enrichlayer/el-linear",
-  "version": "1.39.0",
+  "version": "1.41.0",
   "description": "A pragmatic CLI for Linear.app — deterministic team/label/member resolution, structured issue validation, configurable term enforcement, and a GraphQL escape hatch.",
   "main": "dist/main.js",
   "types": "dist/main.d.ts",