@enrichlayer/el-linear 1.34.1 → 1.36.0

package/README.md

@@ -249,13 +249,14 @@ itself: `el-linear teams list --raw | jq '.[] | {key, id}'`, etc.
 
 ### Gate telemetry (optional)
 
-`issues create` has a duplicate-detection gate. el-linear can record each
-fire/override decision to a local JSONL file so you can measure the gate's
-**override-rate** and tell whether it's too aggressive. It is **off by default**
-and writes nothing unless you opt in (e.g. `export EL_TELEMETRY_DIR=<path>`);
-there is no server or database, and `EL_TELEMETRY_DISABLED=1` forces it off.
-Full opt-in rules, the event schema, and a `jq` reader are in
-[docs/telemetry.md](./docs/telemetry.md).
+`issues create` has a duplicate-detection gate (on by default) and an opt-in
+[SOP-label parent gate](./docs/configuration.md#sop-label-parent-gate-validationsoplabelparentgate).
+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.
+`export EL_TELEMETRY_DIR=<path>`); there is no server or database, and
+`EL_TELEMETRY_DISABLED=1` forces it off. Full opt-in rules, the event schema, and
+a `jq` reader are in [docs/telemetry.md](./docs/telemetry.md).
 
 ### Networking (IPv4 preference)
 
@@ -445,6 +446,7 @@ el-linear <command> --help       # detailed help for one command
 | Comments | `comments {list, read, create, update, delete}` |
 | Labels | `labels {list, create, retire, restore}` |
 | Projects | `projects {list, add-team, remove-team}` |
+| Project updates | `project-updates {create, list, read}` (post a status update to a project's Updates feed) |
 | Cycles | `cycles {list, read}` |
 | Documents | `documents {list, read, create, update, delete}` |
 | Releases | `releases {list, read, create, pipelines}` |
@@ -578,7 +580,7 @@ el-linear projects list --format summary --fields name,state,progress,lead,teams
 # ...
 ```
 
-Unrecognized field names are reported as a `_warnings:` line appended after the summary block (`fields_unprojectable: --format summary on issues list does not project foo, bar; ...`) — same signal scripts get on the JSON path. Resources whose summary formatter doesn't yet wire `--fields` (cycles, milestones, comments, teams, labels, users, documents, templates, attachments, releases, search results) emit the same warning and render their default summary.
+Unrecognized field names are reported as a `_warnings:` line appended after the summary block (`fields_unprojectable: --format summary on issues list does not project foo, bar; ...`) — same signal scripts get on the JSON path. Resources whose summary formatter doesn't yet wire `--fields` (cycles, milestones, project updates, comments, teams, labels, users, documents, templates, attachments, releases, search results) emit the same warning and render their default summary.
 
 ### Windowed metadata (`WindowedMeta`)
 

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

@@ -200,6 +200,21 @@ and outreach tracked in one place.
 > `validation.duplicateDetection: false` (field validation still runs);
 > `validation.enabled: false` turns off all validation.
 
+> **SOP-label parent gate ([DEV-5378](https://linear.app/verticalint/issue/DEV-5378/), opt-in).** When enabled, `el-linear issues create` requires an
+> issue carrying an **SOP-type label** (any name in `validation.sopLabels`,
+> default `["SOP"]`, case-insensitive) to point at a **parent SOP** — `--parent`
+> or `--related-to` must resolve to another SOP-labeled issue — and **blocks
+> (exit non-zero)** otherwise, naming the rule. An SOP with no parent SOP is
+> unfindable by SOP tooling and breaks the catalog topology. It is **off by
+> default** (`validation.sopLabelParentGate: true` turns it on; the Enrich Layer
+> shared team config flips it on) because "SOP" is a workspace-specific
+> taxonomy, not something an open-source install should assume. Escape hatch:
+> `--allow-unparented-sop` (narrow, for an intentionally top-level SOP);
+> `--skip-validation` also bypasses it but skips all field validation. A typo'd
+> or nonexistent parent reference **blocks** (naming the ref) so a mistake can't
+> orphan an SOP; a transport/service error **fails open** with a warning (and a
+> `fail-open` gate event); a resolvable non-SOP parent hard-blocks.
+
 ```bash
 # --include-closed is required so previously-completed duplicates surface.
 # `issues search` defaults to open states (DEV-4478); the duplicate check

package/dist/commands/issue-id.js

@@ -22,11 +22,12 @@ import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 // elsewhere in the workspace. Any addition here is the single point of
 // truth that all skills rely on.
 //
-// Accepted prefixes (DEV-4777 adds bug/spike; DEV-4660 added codex; both
-// mirror tools-repo DEV-4417):
-//   feature | fix | chore | refactor | dev   — SOP-canonical + Linear-CLI direct
+// Accepted prefixes (DEV-4777 adds bug/spike; DEV-4660 added codex; DEV-5342
+// adds the feat short-form alias; all mirror tools-repo DEV-4417/DEV-5334):
+//   feature | feat | fix | chore | refactor | dev — SOP-canonical + Linear-CLI direct
 //   bug | spike                              — sanctioned Linear type labels
 //   codex                                    — Codex-authored branches (codex/<TEAM>-<N>-slug)
+//   feat                                     — short-form alias for feature (DEV-5342)
 // New authoring surfaces (Codex, future agent prefixes) and sanctioned Linear
 // type labels (bug, spike) get first-class issue detection so commit guards,
 // MR descriptions, and session handoff don't go dark on a branch a human
@@ -34,7 +35,7 @@ import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 //
 // Mirror of cli/el-git/src/commands/context.ts:BRANCH_RE in the
 // vertical-int/tools repo. If you change one, change the other.
-const BRANCH_RE = /^(?:feature|fix|chore|refactor|bug|spike|dev|codex)[-/]([A-Z]{2,4})-(\d+)(?:[-/](.*))?$/i;
+const BRANCH_RE = /^(?:feature|feat|fix|chore|refactor|bug|spike|dev|codex)[-/]([A-Z]{2,4})-(\d+)(?:[-/](.*))?$/i;
 export function parseBranchName(branch) {
     const m = branch.match(BRANCH_RE);
     if (!m) {

package/dist/commands/issues.js

@@ -3,6 +3,7 @@ import { loadConfig } from "../config/config.js";
 import { enrichProjectResolverError, enrichValidationErrors, } from "../config/error-enrichment.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";
 import { resolveDefaultStatus } from "../config/status-defaults.js";
 import { enforceTerms } from "../config/term-enforcer.js";
 import { GET_ISSUE_RELATIONS_QUERY, GET_ISSUE_STATE_HISTORY_QUERY, } from "../queries/issues.js";
@@ -544,6 +545,109 @@ async function enforceNoDuplicateIssue(title, options, issuesService) {
     });
     throw new Error(`Issue creation blocked: ${formatDuplicateBlock(matches)}`);
 }
+/**
+ * DEV-5378: create-time SOP-label parent gate. When the issue being created
+ * carries an SOP-type label, require that `--parent` or `--related-to` resolves
+ * to another SOP-labeled issue, and throw otherwise — the deterministic form of
+ * the kaizen skill's Stage-4 rule (parent ALL-1028). An SOP with no parent SOP
+ * is unfindable by `el-sop landscape` and breaks the catalog topology.
+ *
+ * OPT-IN: dormant unless `validation.sopLabelParentGate: true` (see
+ * {@link getSopLabelGateConfig}) — el-linear is MIT/open-source and "SOP" is an
+ * Enrich-Layer-specific taxonomy. Bypassed by `--skip-validation` (blanket) and
+ * the narrow `--allow-unparented-sop` (which records an `overridden` gate event,
+ * mirroring `--allow-duplicate`). The parent-label fetch is best-effort: when a
+ * referenced issue can't be resolved (network / not-found) the gate fails open
+ * with a warning rather than blocking legitimate creation on infra trouble — a
+ * genuinely resolvable non-SOP parent still hard-blocks.
+ */
+async function enforceSopLabelParent(labels, options, issuesService) {
+    if (options.skipValidation) {
+        return;
+    }
+    const { enabled, sopLabels } = getSopLabelGateConfig();
+    if (!enabled) {
+        return;
+    }
+    if (!hasSopLabel(labels, sopLabels)) {
+        return;
+    }
+    const parentRefs = [
+        ...(typeof options.parentTicket === "string" && options.parentTicket
+            ? [options.parentTicket]
+            : []),
+        ...(options.relatedTo ? splitList(options.relatedTo) : []),
+    ];
+    // Record the decision so `el-telemetry gates` can compute override-rate,
+    // mirroring the dup gate (DEV-4834): `overridden` when the caller passed
+    // --allow-unparented-sop and we proceed, `blocked` when we stop creation.
+    const decide = async (reason, unresolvableRefs) => {
+        const gateEvent = { gate: "issues-create-sop-parent" };
+        if (options.allowUnparentedSop) {
+            await emitGateEvent("el-linear", "issues create", {
+                ...gateEvent,
+                outcome: "overridden",
+            });
+            return;
+        }
+        await emitGateEvent("el-linear", "issues create", {
+            ...gateEvent,
+            outcome: "blocked",
+        });
+        throw new Error(`Issue creation blocked: ${formatSopParentBlock({
+            sopLabels,
+            reason,
+            parentRefs,
+            unresolvableRefs,
+        })}`);
+    };
+    // No parent/related at all → deterministic block (no fetch needed).
+    if (parentRefs.length === 0) {
+        await decide("no-parent");
+        return;
+    }
+    // A referenced issue that resolves AND carries an SOP label satisfies the
+    // gate. Fetch per-ref (not batched) so one unresolvable ref doesn't sink a
+    // sibling that would have passed. Classify each failure: a clean
+    // not-found/malformed ref is an unresolvable reference (it contributes to a
+    // block — a typo must not slip through), a transport/service error is infra
+    // trouble (fail open so it can't block legitimate creation).
+    const unresolvableRefs = [];
+    let transportError = false;
+    for (const ref of parentRefs) {
+        try {
+            const issue = await issuesService.getIssueById(ref);
+            if (hasSopLabel(issue.labels.map((l) => l.name), sopLabels)) {
+                return; // valid SOP parent — pass
+            }
+        }
+        catch (err) {
+            if (isUnresolvableReferenceError(err)) {
+                unresolvableRefs.push(ref);
+            }
+            else {
+                transportError = true;
+            }
+        }
+    }
+    // No SOP parent was confirmed. A transport failure may have hidden the real
+    // SOP parent → fail open (best-effort, like the dup gate on a search
+    // failure) and record it so the degradation is measurable (DEV-5378).
+    if (transportError) {
+        await emitGateEvent("el-linear", "issues create", {
+            gate: "issues-create-sop-parent",
+            outcome: "fail-open",
+        });
+        outputWarning(`SOP-parent check could not verify a parent SOP for ${parentRefs.join(", ")} due to a service error; proceeding without blocking.${options.allowUnparentedSop
+            ? ""
+            : " Pass --allow-unparented-sop to silence."}`);
+        return;
+    }
+    // Every reference either resolved to a non-SOP issue or cleanly failed to
+    // resolve (typo / nonexistent) — none is a valid SOP parent → block, naming
+    // any unresolvable refs so a typo reads differently from a real non-SOP parent.
+    await decide("no-sop-parent", unresolvableRefs.length > 0 ? unresolvableRefs : undefined);
+}
 async function handleCreateIssue(title, options, command) {
     const rootOpts = getRootOpts(command);
     const { teamInput, teamId, assigneeId, delegateId, labelIds, status, subscriberIds, priority, } = await resolveCreateInputs(title ?? "", options, rootOpts);
@@ -572,6 +676,15 @@ async function handleCreateIssue(title, options, command) {
     if (title) {
         await enforceNoDuplicateIssue(title, options, issuesService);
     }
+    // DEV-5378: deterministic SOP-label parent gate. Opt-in (dormant unless
+    // validation.sopLabelParentGate). Runs on the post-normalization labels
+    // (resolveCreateInputs rewrote options.labels to the canonical set) and,
+    // when the issue is SOP-labeled, blocks unless --parent/--related-to points
+    // at another SOP-labeled issue. Independent of title, so it runs even on the
+    // --from-template path — though a template that supplies labels server-side
+    // leaves options.labels undefined here, in which case the gate sees no SOP
+    // label and no-ops (same client-side-visibility gap as the dup gate).
+    await enforceSopLabelParent(options.labels ? splitList(options.labels) : [], options, issuesService);
     // Wrap valid issue identifiers as markdown links before creating, so the description
     // saved on Linear has clickable refs from the start. Self-reference can't apply here
     // because the issue doesn't exist yet — pass undefined.
@@ -1137,8 +1250,9 @@ 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)")
+        .option("--skip-validation", "skip all validation (labels, description, assignee, project, duplicate detection, SOP-parent gate)")
         .option("--allow-duplicate", "skip the duplicate-detection gate and create even if a similar issue already exists")
+        .option("--allow-unparented-sop", "skip the SOP-label parent gate and create an SOP-labeled issue without a parent SOP")
         .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/project-updates.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function setupProjectUpdatesCommands(program: Command): void;

package/dist/commands/project-updates.js

@@ -0,0 +1,116 @@
+import { readFileSync } from "node:fs";
+import { CREATE_PROJECT_UPDATE_MUTATION, GET_PROJECT_UPDATE_BY_ID_QUERY, LIST_PROJECT_UPDATES_QUERY, } from "../queries/project-updates.js";
+import { notFoundError } from "../utils/error-messages.js";
+import { createGraphQLService } from "../utils/graphql-service.js";
+import { createLinearService } from "../utils/linear-service.js";
+import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
+const VALID_HEALTH = [
+    "onTrack",
+    "atRisk",
+    "offTrack",
+];
+/**
+ * Resolve the update body from `--body` / `--body-file` (mutually exclusive,
+ * exactly one required) — mirrors the comments-command contract so file-sourced
+ * bodies sidestep shell-quoting traps for markdown/tables/backticks.
+ */
+function resolveBody(options) {
+    if (options.body && options.bodyFile) {
+        throw new Error("--body and --body-file are mutually exclusive — pass one or the other");
+    }
+    if (options.bodyFile) {
+        return readFileSync(options.bodyFile, "utf-8");
+    }
+    if (options.body) {
+        return options.body;
+    }
+    throw new Error("Either --body or --body-file is required");
+}
+/**
+ * Validate an optional `--health` value against Linear's
+ * `ProjectUpdateHealthType` enum. Returns undefined when the flag is omitted
+ * (Linear then defaults the health), throws on an unknown value.
+ */
+function resolveHealth(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (!VALID_HEALTH.includes(value)) {
+        throw new Error(`Invalid --health "${value}" — expected one of: ${VALID_HEALTH.join(", ")}`);
+    }
+    return value;
+}
+async function handleCreateProjectUpdate(options, command) {
+    // Validate local input first so bad --body/--health fails with zero network.
+    const body = resolveBody(options);
+    const health = resolveHealth(options.health);
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const projectId = await linearService.resolveProjectId(options.project);
+    const input = { projectId, body };
+    if (health !== undefined) {
+        input.health = health;
+    }
+    if (options.diffHidden) {
+        input.isDiffHidden = true;
+    }
+    const result = await graphQLService.rawRequest(CREATE_PROJECT_UPDATE_MUTATION, { input });
+    if (!result.projectUpdateCreate.success ||
+        !result.projectUpdateCreate.projectUpdate) {
+        throw new Error(`Failed to create project update on project "${options.project}"`);
+    }
+    outputSuccess(result.projectUpdateCreate.projectUpdate);
+}
+async function handleListProjectUpdates(options, command) {
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const linearService = await createLinearService(rootOpts);
+    const projectId = await linearService.resolveProjectId(options.project);
+    const result = await graphQLService.rawRequest(LIST_PROJECT_UPDATES_QUERY, {
+        projectId,
+        first: parsePositiveInt(options.limit, "--limit"),
+    });
+    if (!result.project) {
+        throw notFoundError("Project", options.project);
+    }
+    const nodes = result.project.projectUpdates.nodes;
+    outputSuccess({ data: nodes, meta: { count: nodes.length } });
+}
+async function handleReadProjectUpdate(updateId, _options, command) {
+    const rootOpts = getRootOpts(command);
+    const graphQLService = await createGraphQLService(rootOpts);
+    const result = await graphQLService.rawRequest(GET_PROJECT_UPDATE_BY_ID_QUERY, { id: updateId });
+    if (!result.projectUpdate) {
+        throw notFoundError("Project update", updateId);
+    }
+    outputSuccess(result.projectUpdate);
+}
+export function setupProjectUpdatesCommands(program) {
+    const projectUpdates = program
+        .command("project-updates")
+        .description("Project update (status post) operations");
+    projectUpdates.action(() => projectUpdates.help());
+    projectUpdates
+        .command("create")
+        .description("Post a status update to a project (appears in the project's Updates feed).")
+        .requiredOption("--project <project>", "project name or ID")
+        .option("--body <body>", "update body markdown (inline)")
+        .option("--body-file <path>", "read update body from file")
+        .option("--health <health>", "project health: onTrack | atRisk | offTrack (omit to leave unset)")
+        .option("--diff-hidden", "hide the progress diff on the update")
+        .option("-q, --quiet", "print one confirmation line (health url) instead of the full JSON")
+        .action(handleAsyncCommand(handleCreateProjectUpdate));
+    projectUpdates
+        .command("list")
+        .description("List status updates posted to a project (newest first).")
+        .requiredOption("--project <project>", "project name or ID")
+        .option("-l, --limit <number>", "limit results", "50")
+        .action(handleAsyncCommand(handleListProjectUpdates));
+    projectUpdates
+        .command("read <updateId>")
+        .description("Get a single project update by its ID.")
+        .action(handleAsyncCommand(handleReadProjectUpdate));
+}

package/dist/config/config.d.ts

@@ -67,6 +67,21 @@ export interface ElLinearConfig {
          * `DEFAULT_DUPLICATE_THRESHOLD` (0.35). Lower = more aggressive.
          */
         duplicateThreshold?: number;
+        /**
+         * OPT-IN SOP-label parent gate (DEV-5378). When `true`, `issues create`
+         * requires an issue carrying an SOP-type label (see `sopLabels`) to point
+         * at a parent SOP via `--parent` or `--related-to`, blocking otherwise.
+         * Defaults to `false` (dormant) — el-linear is MIT/open-source and "SOP"
+         * is an Enrich-Layer-specific taxonomy, so a fresh install stays silent
+         * until a workspace opts in (the EL shared team config flips it on).
+         * Bypass a single create with `--allow-unparented-sop`.
+         */
+        sopLabelParentGate?: boolean;
+        /**
+         * Label names (matched case-insensitively) that mark an issue as an SOP
+         * for the `sopLabelParentGate` check. Defaults to `["SOP"]`.
+         */
+        sopLabels?: string[];
     };
     /**
      * Optional override for the Linear workspace URL key (the part after

package/dist/config/sop-label-validation.d.ts

@@ -0,0 +1,82 @@
+/**
+ * SOP-label parent validation — DEV-5378.
+ *
+ * The el-linear side of the SOP-system enforcement (parent ALL-1028). When an
+ * issue carries an SOP-type label, it must point at a parent SOP so the
+ * `el-sop landscape` catalog topology stays connected — an SOP with no parent
+ * SOP is unfindable and breaks the tree. This turns the kaizen skill's Stage-4
+ * "always give an SOP issue a parent SOP" prose rule into a deterministic
+ * create-time gate, mirroring the DEV-4823 duplicate-detection gate.
+ *
+ * OPT-IN by design. el-linear is MIT and published on npm; most installs are
+ * not Enrich Layer and have no SOP taxonomy. The gate is dormant unless
+ * `validation.sopLabelParentGate: true` is set (the EL workspace flips it on in
+ * its shared team config). This is the opposite of the duplicate-detection gate,
+ * which defaults on — but the dup check is workspace-agnostic, whereas "SOP" is
+ * an Enrich-Layer-specific label taxonomy that a fresh OSS install must not be
+ * surprised by.
+ */
+/**
+ * Default label names that mark an issue as an SOP. Overridable via
+ * `config.validation.sopLabels`. Matched case-insensitively against the
+ * issue's labels.
+ */
+export declare const DEFAULT_SOP_LABELS: string[];
+export interface SopLabelGateConfig {
+    /**
+     * Whether the gate is active. OPT-IN: only true when validation is not
+     * turned off AND `sopLabelParentGate` is explicitly `true`.
+     */
+    enabled: boolean;
+    /** The SOP label names in effect (config override or {@link DEFAULT_SOP_LABELS}). */
+    sopLabels: string[];
+}
+/**
+ * Resolve the SOP-label-parent-gate config from the merged el-linear config.
+ *
+ * The gate is dormant by default. It activates only when validation isn't
+ * disabled (`validation.enabled !== false`) AND the operator has explicitly set
+ * `validation.sopLabelParentGate: true`. An absent or empty `sopLabels` falls
+ * back to {@link DEFAULT_SOP_LABELS}.
+ */
+export declare function getSopLabelGateConfig(): SopLabelGateConfig;
+/**
+ * Case-insensitive membership test: does `labels` contain any of the configured
+ * SOP label names? Returns false for an empty `labels` set.
+ */
+export declare function hasSopLabel(labels: string[], sopLabels: string[]): boolean;
+/**
+ * Distinguish a reference that cleanly does NOT resolve to a real issue (a
+ * typo'd or nonexistent `--parent` / `--related-to`) from a transport/service
+ * failure (network, GraphQL 5xx, timeout).
+ *
+ * `getIssueById` throws a plain `Error` for both — this codebase has no error
+ * `code` or subclass to switch on — so we key on the two message families it
+ * produces for an *unresolvable reference*:
+ *   - `notFoundError` → `… not found.`  (well-formed ref, no such issue)
+ *   - `parseIssueIdentifier` → `Invalid issue identifier format: …` /
+ *     `Invalid issue number in identifier: …`  (malformed ref)
+ * Everything else — notably `GraphQL request failed: …` / `GraphQL query
+ * failed` from `graphql-service` — is treated as transport and fails open.
+ *
+ * This is a correctness distinction, not just telemetry: an unresolvable
+ * reference must BLOCK. Otherwise a typo'd `--related-to` on an SOP issue fails
+ * open, the issue is created, and the *follow-up* `createRelations` throws —
+ * leaving an orphan SOP on the board (the exact gap DEV-5378 cycle-1 caught). A
+ * transport error must FAIL OPEN so infra trouble can't block legitimate work.
+ */
+export declare function isUnresolvableReferenceError(err: unknown): boolean;
+/**
+ * Render the human/agent-facing block thrown when an SOP-labeled issue has no
+ * SOP parent. `reason` distinguishes "no parent at all" from "one or more
+ * references present but none resolves to an SOP-labeled issue", so the message
+ * points at the exact fix. When some references couldn't be resolved at all,
+ * `unresolvableRefs` names them (a typo'd ref reads differently from a real but
+ * non-SOP parent). Names the rule and the `--allow-unparented-sop` escape hatch.
+ */
+export declare function formatSopParentBlock(opts: {
+    sopLabels: string[];
+    reason: "no-parent" | "no-sop-parent";
+    parentRefs: string[];
+    unresolvableRefs?: string[];
+}): string;

package/dist/config/sop-label-validation.js

@@ -0,0 +1,103 @@
+/**
+ * SOP-label parent validation — DEV-5378.
+ *
+ * The el-linear side of the SOP-system enforcement (parent ALL-1028). When an
+ * issue carries an SOP-type label, it must point at a parent SOP so the
+ * `el-sop landscape` catalog topology stays connected — an SOP with no parent
+ * SOP is unfindable and breaks the tree. This turns the kaizen skill's Stage-4
+ * "always give an SOP issue a parent SOP" prose rule into a deterministic
+ * create-time gate, mirroring the DEV-4823 duplicate-detection gate.
+ *
+ * OPT-IN by design. el-linear is MIT and published on npm; most installs are
+ * not Enrich Layer and have no SOP taxonomy. The gate is dormant unless
+ * `validation.sopLabelParentGate: true` is set (the EL workspace flips it on in
+ * its shared team config). This is the opposite of the duplicate-detection gate,
+ * which defaults on — but the dup check is workspace-agnostic, whereas "SOP" is
+ * an Enrich-Layer-specific label taxonomy that a fresh OSS install must not be
+ * surprised by.
+ */
+import { loadConfig } from "./config.js";
+/**
+ * Default label names that mark an issue as an SOP. Overridable via
+ * `config.validation.sopLabels`. Matched case-insensitively against the
+ * issue's labels.
+ */
+export const DEFAULT_SOP_LABELS = ["SOP"];
+/**
+ * Resolve the SOP-label-parent-gate config from the merged el-linear config.
+ *
+ * The gate is dormant by default. It activates only when validation isn't
+ * disabled (`validation.enabled !== false`) AND the operator has explicitly set
+ * `validation.sopLabelParentGate: true`. An absent or empty `sopLabels` falls
+ * back to {@link DEFAULT_SOP_LABELS}.
+ */
+export function getSopLabelGateConfig() {
+    const validation = loadConfig().validation;
+    const enabled = validation?.enabled !== false && validation?.sopLabelParentGate === true;
+    const sopLabels = validation?.sopLabels && validation.sopLabels.length > 0
+        ? validation.sopLabels
+        : DEFAULT_SOP_LABELS;
+    return { enabled, sopLabels };
+}
+/**
+ * Case-insensitive membership test: does `labels` contain any of the configured
+ * SOP label names? Returns false for an empty `labels` set.
+ */
+export function hasSopLabel(labels, sopLabels) {
+    const wanted = new Set(sopLabels.map((l) => l.toLowerCase()));
+    return labels.some((l) => wanted.has(l.toLowerCase()));
+}
+/**
+ * Distinguish a reference that cleanly does NOT resolve to a real issue (a
+ * typo'd or nonexistent `--parent` / `--related-to`) from a transport/service
+ * failure (network, GraphQL 5xx, timeout).
+ *
+ * `getIssueById` throws a plain `Error` for both — this codebase has no error
+ * `code` or subclass to switch on — so we key on the two message families it
+ * produces for an *unresolvable reference*:
+ *   - `notFoundError` → `… not found.`  (well-formed ref, no such issue)
+ *   - `parseIssueIdentifier` → `Invalid issue identifier format: …` /
+ *     `Invalid issue number in identifier: …`  (malformed ref)
+ * Everything else — notably `GraphQL request failed: …` / `GraphQL query
+ * failed` from `graphql-service` — is treated as transport and fails open.
+ *
+ * This is a correctness distinction, not just telemetry: an unresolvable
+ * reference must BLOCK. Otherwise a typo'd `--related-to` on an SOP issue fails
+ * open, the issue is created, and the *follow-up* `createRelations` throws —
+ * leaving an orphan SOP on the board (the exact gap DEV-5378 cycle-1 caught). A
+ * transport error must FAIL OPEN so infra trouble can't block legitimate work.
+ */
+export function isUnresolvableReferenceError(err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return (message.includes("not found.") ||
+        message.includes("Invalid issue identifier format") ||
+        message.includes("Invalid issue number in identifier"));
+}
+/**
+ * Render the human/agent-facing block thrown when an SOP-labeled issue has no
+ * SOP parent. `reason` distinguishes "no parent at all" from "one or more
+ * references present but none resolves to an SOP-labeled issue", so the message
+ * points at the exact fix. When some references couldn't be resolved at all,
+ * `unresolvableRefs` names them (a typo'd ref reads differently from a real but
+ * non-SOP parent). Names the rule and the `--allow-unparented-sop` escape hatch.
+ */
+export function formatSopParentBlock(opts) {
+    const sopList = opts.sopLabels.join(", ");
+    const head = `SOP-labeled issue must point at a parent SOP (SOP label(s): ${sopList}).\n` +
+        "  An SOP with no parent SOP is unfindable by `el-sop landscape` and breaks the catalog topology.\n";
+    let detail;
+    if (opts.reason === "no-parent") {
+        detail =
+            "  This issue has no --parent or --related-to. Add one that points at an SOP-labeled issue.\n";
+    }
+    else {
+        detail = `  No referenced issue resolves to an SOP-labeled issue (referenced: ${opts.parentRefs.join(", ")}).\n`;
+        if (opts.unresolvableRefs && opts.unresolvableRefs.length > 0) {
+            detail += `  Could not resolve: ${opts.unresolvableRefs.join(", ")} — check the identifier exists.\n`;
+        }
+        detail +=
+            "  Point --parent or --related-to at an existing SOP-labeled issue.\n";
+    }
+    const hatch = "  If this SOP is intentionally top-level, re-run with --allow-unparented-sop.";
+    return head + detail + hatch;
+}

package/dist/main.js

@@ -20,6 +20,7 @@ import { setupIssuesCommands } from "./commands/issues.js";
 import { setupLabelsCommands } from "./commands/labels.js";
 import { setupProfileCommands } from "./commands/profile.js";
 import { setupProjectMilestonesCommands } from "./commands/project-milestones.js";
+import { setupProjectUpdatesCommands } from "./commands/project-updates.js";
 import { setupProjectsCommands } from "./commands/projects.js";
 import { setupReadShortcut } from "./commands/read-shortcut.js";
 import { setupRefsCommands } from "./commands/refs.js";
@@ -65,9 +66,13 @@ program
     .option("--profile <name>", "named profile (under ~/.config/el-linear/profiles/<name>/) for this invocation. Overrides EL_LINEAR_PROFILE env + the on-disk active-profile marker.")
     .option("--json", "output as JSON (default, accepted for compatibility)")
     .option("--format <kind>", "output format: json (default, structured envelope) or summary (human-readable)", "json")
-    .option("--raw", "strip { data, meta } wrapper from list output — emit the array directly")
+    .option("--raw", "strip { data, meta } wrapper from list output — emit the array directly. " +
+    "Warnings (e.g. --fields fields_unresolved) can't ride on a bare array, so " +
+    "they are written to stderr prefixed `_warnings: `, keeping stdout a pure JSON array")
     .option("--jq <filter>", "apply a jq filter to the JSON output")
-    .option("--fields <fields>", "filter output to specific fields (comma-separated)")
+    .option("--fields <fields>", "filter output to specific fields (comma-separated). Unresolved fields are " +
+    "emitted as null plus a `fields_unresolved:` warning — in the JSON " +
+    "envelope's `_warnings`, or on stderr when output is a bare array (with --raw)")
     .option("--no-cache", "bypass the on-disk cache for `teams list` / `labels list` / `projects list`");
 program.hook("preAction", (_thisCommand, actionCommand) => {
     const rootOpts = actionCommand.optsWithGlobals();
@@ -143,6 +148,7 @@ setupReleasesCommands(program);
 setupProjectsCommands(program);
 setupCyclesCommands(program);
 setupProjectMilestonesCommands(program);
+setupProjectUpdatesCommands(program);
 setupEmbedsCommands(program);
 setupTeamsCommands(program);
 setupTemplatesCommands(program);

package/dist/queries/project-updates-types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Typed response shapes for the queries in `./project-updates.ts`.
+ * See `./issues-types.ts` for the rationale (ALL-937).
+ *
+ * All three queries (create / list / read) select the same
+ * `PROJECT_UPDATE_FRAGMENT`, so one node shape covers every consumer.
+ */
+export type ProjectUpdateHealth = "onTrack" | "atRisk" | "offTrack";
+interface ProjectUpdateProjectRef {
+    id: string;
+    name: string;
+}
+interface ProjectUpdateUserRef {
+    id: string;
+    name: string;
+    displayName: string | null;
+}
+/**
+ * Mirrors `PROJECT_UPDATE_FRAGMENT` — the full selection set shared by the
+ * create mutation, the project-scoped list, and the by-id read.
+ */
+export interface ProjectUpdateNode {
+    id: string;
+    body: string | null;
+    health: ProjectUpdateHealth | null;
+    url: string | null;
+    slugId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    editedAt: string | null;
+    user: ProjectUpdateUserRef | null;
+    project: ProjectUpdateProjectRef | null;
+}
+export interface CreateProjectUpdateResponse {
+    projectUpdateCreate: {
+        success: boolean;
+        projectUpdate: ProjectUpdateNode | null;
+    };
+}
+export interface ListProjectUpdatesResponse {
+    project: {
+        id: string;
+        name: string;
+        projectUpdates: {
+            nodes: ProjectUpdateNode[];
+        };
+    } | null;
+}
+export interface GetProjectUpdateByIdResponse {
+    projectUpdate: ProjectUpdateNode | null;
+}
+export {};

package/dist/queries/project-updates-types.js

@@ -0,0 +1,8 @@
+/**
+ * Typed response shapes for the queries in `./project-updates.ts`.
+ * See `./issues-types.ts` for the rationale (ALL-937).
+ *
+ * All three queries (create / list / read) select the same
+ * `PROJECT_UPDATE_FRAGMENT`, so one node shape covers every consumer.
+ */
+export {};

package/dist/queries/project-updates.d.ts

@@ -0,0 +1,3 @@
+export declare const CREATE_PROJECT_UPDATE_MUTATION = "\n  mutation ProjectUpdateCreate($input: ProjectUpdateCreateInput!) {\n    projectUpdateCreate(input: $input) {\n      success\n      projectUpdate {\n        \n  id\n  body\n  health\n  url\n  slugId\n  createdAt\n  updatedAt\n  editedAt\n  user {\n    id\n    name\n    displayName\n  }\n  project {\n    id\n    name\n  }\n\n      }\n    }\n  }\n";
+export declare const LIST_PROJECT_UPDATES_QUERY = "\n  query ListProjectUpdates($projectId: String!, $first: Int!) {\n    project(id: $projectId) {\n      id\n      name\n      projectUpdates(first: $first, orderBy: createdAt) {\n        nodes {\n          \n  id\n  body\n  health\n  url\n  slugId\n  createdAt\n  updatedAt\n  editedAt\n  user {\n    id\n    name\n    displayName\n  }\n  project {\n    id\n    name\n  }\n\n        }\n      }\n    }\n  }\n";
+export declare const GET_PROJECT_UPDATE_BY_ID_QUERY = "\n  query GetProjectUpdate($id: String!) {\n    projectUpdate(id: $id) {\n      \n  id\n  body\n  health\n  url\n  slugId\n  createdAt\n  updatedAt\n  editedAt\n  user {\n    id\n    name\n    displayName\n  }\n  project {\n    id\n    name\n  }\n\n    }\n  }\n";

package/dist/queries/project-updates.js

@@ -0,0 +1,49 @@
+const PROJECT_UPDATE_FRAGMENT = `
+  id
+  body
+  health
+  url
+  slugId
+  createdAt
+  updatedAt
+  editedAt
+  user {
+    id
+    name
+    displayName
+  }
+  project {
+    id
+    name
+  }
+`;
+export const CREATE_PROJECT_UPDATE_MUTATION = `
+  mutation ProjectUpdateCreate($input: ProjectUpdateCreateInput!) {
+    projectUpdateCreate(input: $input) {
+      success
+      projectUpdate {
+        ${PROJECT_UPDATE_FRAGMENT}
+      }
+    }
+  }
+`;
+export const LIST_PROJECT_UPDATES_QUERY = `
+  query ListProjectUpdates($projectId: String!, $first: Int!) {
+    project(id: $projectId) {
+      id
+      name
+      projectUpdates(first: $first, orderBy: createdAt) {
+        nodes {
+          ${PROJECT_UPDATE_FRAGMENT}
+        }
+      }
+    }
+  }
+`;
+export const GET_PROJECT_UPDATE_BY_ID_QUERY = `
+  query GetProjectUpdate($id: String!) {
+    projectUpdate(id: $id) {
+      ${PROJECT_UPDATE_FRAGMENT}
+    }
+  }
+`;

package/dist/utils/formatters/summary.d.ts

@@ -30,6 +30,8 @@ export declare function formatCycleSummary(cycle: Record<string, unknown>): stri
 export declare function formatCycleList(cycles: unknown[]): string;
 export declare function formatMilestoneSummary(milestone: Record<string, unknown>): string;
 export declare function formatMilestoneList(milestones: unknown[]): string;
+export declare function formatProjectUpdateSummary(update: Record<string, unknown>): string;
+export declare function formatProjectUpdateList(updates: unknown[]): string;
 export declare function formatTeamList(teams: unknown[]): string;
 export declare function formatLabelList(labels: unknown[]): string;
 /**
@@ -68,7 +70,7 @@ export declare function formatSearchResultList(results: unknown[]): string;
  * the full payload. Lists fall back to a simple bulleted list.
  */
 export declare function formatGenericSummary(value: unknown): string;
-export type ResourceKind = "issue" | "issue-list" | "project" | "project-list" | "comment" | "comment-list" | "cycle" | "cycle-list" | "milestone" | "milestone-list" | "team-list" | "label-list" | "user" | "user-list" | "document" | "document-list" | "template" | "template-list" | "attachment-list" | "release" | "release-list" | "search-result-list" | "relation-list" | "issue-relation-list" | "empty-list" | "generic";
+export type ResourceKind = "issue" | "issue-list" | "project" | "project-list" | "comment" | "comment-list" | "cycle" | "cycle-list" | "milestone" | "milestone-list" | "project-update" | "project-update-list" | "team-list" | "label-list" | "user" | "user-list" | "document" | "document-list" | "template" | "template-list" | "attachment-list" | "release" | "release-list" | "search-result-list" | "relation-list" | "issue-relation-list" | "empty-list" | "generic";
 /**
  * Heuristic — used by the central `outputSuccess` path which doesn't know
  * which command produced the payload. Looks at the shape of the data to

package/dist/utils/formatters/summary.js

@@ -655,6 +655,35 @@ export function formatMilestoneList(milestones) {
         { header: "PROJECT", minWidth: 7, extract: (m) => getName(m.project) },
     ], { emptyText: "(no milestones)", itemNoun: "milestone" });
 }
+// ── project updates ────────────────────────────────────────────
+export function formatProjectUpdateSummary(update) {
+    const headerLine = `project-update ${s(update.id)}`;
+    const fields = [
+        { label: "Health", value: s(update.health) },
+        { label: "Project", value: getName(update.project) },
+        { label: "Author", value: getName(update.user) },
+        { label: "Created", value: s(update.createdAt) },
+        { label: "URL", value: s(update.url) },
+    ];
+    const header = renderHeader(fields);
+    const body = clipDescription(update.body);
+    const parts = [headerLine, header];
+    if (body)
+        parts.push("", body);
+    return parts.filter((p) => p !== "").join("\n");
+}
+export function formatProjectUpdateList(updates) {
+    return renderTable(updates.map((raw) => asObj(raw) ?? {}), [
+        { header: "HEALTH", minWidth: 6, extract: (u) => s(u.health) },
+        { header: "AUTHOR", minWidth: 6, extract: (u) => getName(u.user) },
+        {
+            header: "CREATED",
+            minWidth: 7,
+            extract: (u) => s(u.createdAt).slice(0, 10),
+        },
+        { header: "URL", minWidth: 3, maxWidth: 60, extract: (u) => s(u.url) },
+    ], { emptyText: "(no project updates)", itemNoun: "project update" });
+}
 // ── teams ──────────────────────────────────────────────────────
 export function formatTeamList(teams) {
     return renderTable(teams.map((raw) => asObj(raw) ?? {}), [
@@ -1036,6 +1065,10 @@ export function inferKindFromPayload(value) {
         "progress" in obj &&
         ("state" in obj || "lead" in obj || "teams" in obj))
         return "project";
+    // Project updates carry body + createdAt + user like comments; `health` is
+    // the distinguishing field, so this must precede the comment check.
+    if ("body" in obj && "health" in obj)
+        return "project-update";
     if ("body" in obj && "createdAt" in obj && "user" in obj)
         return "comment";
     if (("number" in obj || "isActive" in obj) &&
@@ -1079,6 +1112,10 @@ function inferListKind(items) {
         }
         return "issue-list";
     }
+    // Project-update rows carry body + createdAt like comments; `health` is the
+    // distinguishing field, so this must precede the comment-list check.
+    if ("body" in sample && "health" in sample)
+        return "project-update-list";
     if ("body" in sample && "createdAt" in sample)
         return "comment-list";
     if ("progress" in sample && "name" in sample) {
@@ -1168,6 +1205,10 @@ export function dispatch(kind, payload, fields) {
             return formatMilestoneSummary((obj ?? {}));
         case "milestone-list":
             return formatMilestoneList(list ?? []);
+        case "project-update":
+            return formatProjectUpdateSummary((obj ?? {}));
+        case "project-update-list":
+            return formatProjectUpdateList(list ?? []);
         case "team-list":
             return formatTeamList(list ?? []);
         case "label-list":
@@ -1230,6 +1271,11 @@ export function formatLine(payload) {
     if (kind === "comment" && obj) {
         return `comment ${s(obj.id)}`;
     }
+    if (kind === "project-update" && obj) {
+        // create doesn't carry an identifier/title — health + url are the
+        // stable handles a caller needs (matches the summary header style).
+        return `${s(obj.health)}  ${s(obj.url)}`;
+    }
     if (kind === "relation-list") {
         return formatRelationLine(payload);
     }

package/dist/utils/gate-telemetry.d.ts

@@ -25,7 +25,13 @@ export declare function decideGateLedger(opts: {
 export interface GateEvent {
     /** Stable gate id, e.g. `issues-create-dup`. */
     gate: string;
-    outcome: "blocked" | "overridden";
+    /**
+     * `blocked` — the gate stopped creation. `overridden` — a gate-specific
+     * override flag let a would-block proceed. `fail-open` — the gate could not
+     * evaluate (infra/service error) and let creation proceed rather than block
+     * on trouble; tracked so degradation is measurable (DEV-5378).
+     */
+    outcome: "blocked" | "overridden" | "fail-open";
     /** Highest candidate similarity that triggered the gate (0–1). */
     topScore?: number;
     /** How many candidates crossed the threshold. */

package/dist/utils/output.js

@@ -78,6 +78,12 @@ function filterFields(obj, fields, unresolved) {
             const perItem = new Set();
             const projected = filterFields(item, fields, perItem);
             for (const field of fields) {
+                // A primitive item short-circuits: filterFields returns it
+                // unchanged and records NOTHING in perItem, so every field counts
+                // as resolved here — a mixed array holding one primitive suppresses
+                // the unresolved warning for all fields. Acceptable: a primitive
+                // item can't meaningfully be projected, and heterogeneous lists
+                // legitimately have per-item gaps.
                 if (!perItem.has(field)) {
                     resolvedSomewhere.add(field);
                 }
@@ -208,20 +214,19 @@ export function outputSuccess(data) {
         }
         else if (output !== null && typeof output === "object") {
             const obj = output;
-            if (Array.isArray(obj.data)) {
-                output = {
-                    ...obj,
-                    data: filterFields(obj.data, fieldsFilter, unresolved),
-                };
-            }
-            else if (obj.data !== null &&
+            if (obj.data !== null &&
                 obj.data !== undefined &&
                 typeof obj.data === "object") {
-                // Envelope with an OBJECT data payload (e.g. el-git context):
-                // project inside `data`, same as the array branch. Before
-                // DEV-5323 this fell through to root filtering, so
-                // `--fields branch,issueId` on an envelope returned `{}`.
-                // Paths are relative to `data` for every envelope shape.
+                // Envelope with a `data` payload — project inside `data`,
+                // whether it's an array (list envelope) or an object (e.g.
+                // el-git context). Arrays ARE objects, so this single
+                // `typeof === "object"` check subsumes the former separate
+                // `Array.isArray(obj.data)` arm (DEV-5339 collapsed the two
+                // byte-identical branches); `filterFields` dispatches on
+                // array-vs-object internally. Paths are relative to `data` for
+                // every envelope shape. Before DEV-5323 the object case fell
+                // through to root filtering, so `--fields branch,issueId` on an
+                // envelope returned `{}`.
                 output = {
                     ...obj,
                     data: filterFields(obj.data, fieldsFilter, unresolved),
@@ -261,11 +266,31 @@ export function outputSuccess(data) {
     // fields_unprojectable surfaced from a prior dispatch) and embed
     // them as `_warnings` on the envelope.
     const warnings = [...drainWarnings(), ...drainSummaryFieldWarnings()];
-    if (warnings.length > 0 &&
-        output !== null &&
-        typeof output === "object" &&
-        !Array.isArray(output)) {
-        output = { ...output, _warnings: warnings };
+    if (warnings.length > 0) {
+        if (output !== null &&
+            typeof output === "object" &&
+            !Array.isArray(output)) {
+            output = { ...output, _warnings: warnings };
+        }
+        else {
+            // Bare-array (or primitive / null) output has no envelope object to
+            // carry `_warnings`. This is the DEV-5339 fix: previously the buffer
+            // was drained above but only re-embedded for object output, so a
+            // warning was silently dropped on a top-level array payload AND on
+            // `--raw` (which unwraps { data: [...] } to a bare array *before*
+            // this point) — losing exactly the DEV-5323 `fields_unresolved:`
+            // fail-visible signal on the `--raw` form our own CLAUDE.md
+            // recommends to agents. Route each warning to STDERR prefixed
+            // `_warnings: ` so the signal always reaches the consumer while
+            // stdout stays a pure JSON array (safe to pipe to `jq`). Mirrors the
+            // summary path's `_warnings:` line convention — that path uses
+            // logger.info because its stdout is already human text; here stdout
+            // must remain machine-parseable JSON, so we use logger.error
+            // (stderr).
+            for (const w of warnings) {
+                logger.error(`_warnings: ${w}`);
+            }
+        }
     }
     if (jqFilter) {
         const json = JSON.stringify(output);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enrichlayer/el-linear",
-  "version": "1.34.1",
+  "version": "1.36.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",