@enrichlayer/el-linear 1.43.1 → 1.44.1

package/README.md

@@ -145,6 +145,33 @@ EL_LINEAR_PROFILE=forage el-linear teams list
 el-linear profile remove old-profile
 ```
 
+### Recommended for multiple workspaces: pin the repo
+
+If you work across several workspaces, **pin each repo to the profile it belongs to** instead of relying on `profile use`. A pin is scoped to the repo, so a write in that repo always targets the right workspace no matter what the machine-global default happens to be.
+
+```bash
+# In a repo, pin it to the profile it belongs to (defaults to the active one):
+el-linear profile pin forage
+
+# Show the resolved pin + where it came from:
+el-linear profile pin --show
+
+# Pin this exact origin owner/repo in your global user config instead:
+el-linear profile pin work --global
+
+# Remove the repo-local pin:
+el-linear profile unpin
+
+# Remove this repo's exact owner/repo entry from the global user config:
+el-linear profile unpin --global
+```
+
+A repo-local pin is stored in `.el-git.json` at the repo root as `{ "linearProfile": "<name>" }`. el-linear, el-git, and el-session read the same file and resolve the repo to the same workspace.
+
+`--global` writes the exact origin `owner/repo` entry into `~/.config/el-git/linear-profiles.json`; the resolver also honors manually configured `owner/*` wildcard entries. The repo-local file wins over the global table.
+
+When a write command (`issues create` / `comments create`) runs under the bare machine-global default in a repo with no effective pin, el-linear prints a one-line, non-blocking stderr hint suggesting `profile pin`. Silence it with `EL_LINEAR_NO_PIN_HINT=1` (or `--quiet`).
+
 Fix or clean up a single member's aliases/handles without hand-editing
 `config.json` — `profile members` operates directly on the active profile's
 on-disk config (no Linear API round-trip):
@@ -164,8 +191,11 @@ The active profile is selected by, in priority:
 
 1. `--profile <name>` flag (per-invocation)
 2. `EL_LINEAR_PROFILE` env var
-3. `~/.config/el-linear/active-profile` (one-line marker, written by `profile use`)
-4. Legacy single-file layout (`~/.config/el-linear/{token,config.json}`)
+3. **Repo pin** — `.el-git.json` at the repo root, else the `owner/repo` /
+   `owner/*` entry in `~/.config/el-git/linear-profiles.json` (see
+   [Recommended for multiple workspaces](#recommended-for-multiple-workspaces-pin-the-repo))
+4. `~/.config/el-linear/active-profile` (one-line marker, written by `profile use`)
+5. Legacy single-file layout (`~/.config/el-linear/{token,config.json}`)
 
 The legacy fallback means **existing single-profile users see no
 behavior change** — profiles are purely opt-in.
@@ -180,7 +210,10 @@ flag and env var are per-invocation and never touch the marker file, so they
 compose safely with any number of concurrent sessions each pinned to their
 own workspace. Reserve `profile use` for a human's own interactive default
 switch; `profile use`/`profile add` print a loud warning when they change the
-global marker so the blast radius is visible instead of silent.
+global marker so the blast radius is visible instead of silent. Better still
+for a human who works across workspaces: **`profile pin` each repo** (above) —
+the pin sits above the global marker in the precedence list, so the right
+workspace is selected automatically per-repo without any per-command flag.
 
 ## Migrating from v1.0–1.3
 
@@ -731,6 +764,15 @@ el-linear comments list DEV-123 --body
 # Full comment body...
 ```
 
+Both `--body` surfaces treat "no text to print" as a failure rather than an
+empty success, so a caller never has to guess whether silence meant "nothing is
+there" or "the fetch silently dropped it": `comments read --body` exits 1 when
+the comment has no body, and `comments list --body` exits 1 with
+`el-linear: DEV-123 has no comments` (or `… has N comments, none with a body`)
+and writes nothing to stdout. The structured surfaces need no such signal and
+stay exit 0 — `--format summary` prints `(no results)` and the JSON envelope
+carries `meta.count`.
+
 ### One-line write confirmations: `-q, --quiet`
 
 `issues create|update`, `issues relate`, and `comments create|update` accept

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

@@ -121,6 +121,14 @@ el-linear comments list DEV-123 --format json 2>&1 | python3 -c "import json,sys
 `#comment-<hash>`. `comments list --format summary` includes each comment id
 so you can copy it straight into `comments read`.
 
+Empty output from a `--body` surface is never a silent success. `comments list
+--body` exits 1 with `el-linear: DEV-123 has no comments` on stderr when the
+issue has none (and `… has N comments, none with a body` when every body came
+back blank), matching `comments read --body`'s guard — so "no comments" stays
+distinguishable from "the fetch silently dropped the list". `--format summary`
+(`(no results)`) and the JSON envelope (`meta.count`) report emptiness in band
+and stay exit 0.
+
 ### Attachment reads and downloads
 
 List attachments first, then use the attachment ID or exact title. Text files
@@ -177,6 +185,14 @@ Every issue should communicate **why** the work matters and **what** success loo
 ### Example
 
 ```markdown
+## Intake decision
+- Needed: Yes — contact tracking is split across spreadsheets, Linear, and memory.
+- Worth doing: Yes — outbound scale makes the fragmentation costly now, not later.
+- Existing work: searched "CRM", "contact tracking" with --include-closed; no duplicate.
+- Owner: Nico (operations tooling).
+- Placement: OPS / Sales infrastructure; self-hosted on the Hetzner box.
+- Decision: PROCEED
+
 ## Set up a self-hosted CRM
 
 The team needs a CRM to replace fragmented contact tracking
@@ -195,6 +211,26 @@ and outreach tracked in one place.
 
 ---
 
+## Intake Decision Block (MANDATORY, blocking)
+
+**`el-linear issues create` refuses any description without a `## Intake decision` section.** It must open the description, and the six lines must appear in this order:
+
+```markdown
+## Intake decision
+- Needed: Yes — <why this is needed>
+- Worth doing: Yes — <why the value exceeds the cost>
+- Existing work: <duplicate/search result and evidence>
+- Owner: <canonical owner or source of truth>
+- Placement: <team/project/repository/document path>
+- Decision: PROCEED
+```
+
+Write it **before** composing the rest of the body. The gate runs before the create POST, so omitting it fails the call outright — nothing is written, and a finished issue body then has to be reassembled around a section you were never told to include.
+
+The point is that the decision is *recorded*, not merely reached: `Existing work` cites the search you actually ran, and `Owner`/`Placement` name a concrete destination rather than a plausible one. It is the same discipline the two gates below enforce mechanically, applied to the judgment they cannot check.
+
+Escape hatch: `--allow-missing-intake-decision`, which is recorded. It exists for an **accountable human** who has approved an exceptional create — not for an agent that would rather not write the block. `--skip-validation` also bypasses it but disables every other field check too, so prefer the narrow flag.
+
 ## Duplicate & Related Issues Check (MANDATORY)
 
 **Search before creating. No exceptions.**
@@ -366,6 +402,7 @@ Don't start implementation work on an unassigned issue — the assignee is the p
 
 Complete ALL items before creating any issue:
 
+- [ ] **Intake decision** — description opens with the `## Intake decision` block (above). Blocking.
 - [ ] **Duplicate & related check** — searched for existing issues, linked related ones (above).
 - [ ] **Team** — ask user if unclear (`el-linear teams list`).
 - [ ] **Assignee** — ask user if unclear (`el-linear users list --active`).

package/dist/commands/comments.js

@@ -1,4 +1,5 @@
 import { readFileSync } from "node:fs";
+import { maybeEmitPinMismatchHint } from "../config/pin-hint.js";
 import { resolveUserDisplayName } from "../config/resolver.js";
 import { CREATE_COMMENT_MUTATION, DELETE_COMMENT_MUTATION, GET_COMMENT_QUERY, LIST_COMMENTS_QUERY, UPDATE_COMMENT_MUTATION, } from "../queries/comments.js";
 import { autoLinkReferences, } from "../utils/auto-link-references.js";
@@ -134,6 +135,44 @@ function formatCommentBodyBlocks(comments) {
     })
         .join("\n\n---\n\n");
 }
+/**
+ * Why the `--body` list surface has nothing to print, or `null` when it does.
+ *
+ * Split out from the printer so the two "no text" cases stay distinguishable in
+ * the message: zero comments is a fact about the issue, while comments that all
+ * carry empty bodies is the shape a partially-dropped payload takes.
+ */
+function describeMissingCommentBodies(comments) {
+    if (comments.length === 0) {
+        return "has no comments";
+    }
+    const hasBody = comments.some((comment) => typeof comment.body === "string" && comment.body.trim() !== "");
+    if (!hasBody) {
+        return `has ${comments.length} comment${comments.length === 1 ? "" : "s"}, none with a body`;
+    }
+    return null;
+}
+/**
+ * List-surface sibling of `printRawCommentBody`. `--body` is a raw-text
+ * extraction contract, so writing a lone newline and exiting 0 would make "this
+ * issue has no comments" byte-identical to "the fetch or render silently
+ * dropped the list" — no caller could tell the two apart. Mirror the
+ * single-comment guard exactly: nothing on stdout, a stderr hint, exit 1, so
+ * scripts branch on the exit code (DEV-7160).
+ *
+ * The structured surfaces need no such guard — `--format summary` prints
+ * `(no results)` and the JSON envelope carries `meta.count`, both of which say
+ * "empty" in band.
+ */
+function printRawCommentBodyBlocks(comments, label) {
+    const missing = describeMissingCommentBodies(comments);
+    if (missing === null) {
+        process.stdout.write(`${formatCommentBodyBlocks(comments)}\n`);
+        return;
+    }
+    process.stderr.write(`el-linear: ${label} ${missing}\n`);
+    process.exit(1);
+}
 /**
  * Wrap valid issue references in a comment body as markdown links — same logic as for
  * issue descriptions. Returns the rewritten body plus the validated identifier→UUID map
@@ -186,6 +225,9 @@ async function autoLinkCommentReferences(args) {
 }
 async function handleCreateComment(issueId, options, command) {
     const rootOpts = getRootOpts(command);
+    // DEV-7277: non-blocking nudge when this comment is landing via the
+    // machine-global active profile in a repo that hasn't pinned a workspace.
+    maybeEmitPinMismatchHint({ hasProfileFlag: Boolean(rootOpts.profile) });
     const graphQLService = await createGraphQLService(rootOpts);
     const linearService = await createLinearService(rootOpts);
     // Apply messageFooter (config or --footer flag) before any further
@@ -358,7 +400,7 @@ async function handleListComments(issueId, options, command) {
     const fullBodySummary = options.truncate === false && getOutputFormat() === "summary";
     const nodes = result.issue.comments.nodes.map((comment) => transformComment(comment, { fullBodySummary }));
     if (options.body === true) {
-        process.stdout.write(`${formatCommentBodyBlocks(nodes)}\n`);
+        printRawCommentBodyBlocks(nodes, result.issue.identifier);
         return;
     }
     outputSuccess({

package/dist/commands/issues.js

@@ -4,6 +4,7 @@ import { enrichProjectResolverError, enrichValidationErrors, } from "../config/e
 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 { maybeEmitPinMismatchHint } from "../config/pin-hint.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";
@@ -812,6 +813,10 @@ async function enforceIntakeDecision(description, options) {
 }
 async function handleCreateIssue(title, options, command) {
     const rootOpts = getRootOpts(command);
+    // DEV-7277: non-blocking nudge when this write is landing via the
+    // machine-global active profile in a repo that hasn't pinned a workspace.
+    // stderr only; never blocks; suppressed by --quiet / EL_LINEAR_NO_PIN_HINT.
+    maybeEmitPinMismatchHint({ hasProfileFlag: Boolean(rootOpts.profile) });
     // DEV-5920 (cycle-2): resolve the description exactly ONCE, before anything
     // else. On create, resolveDescription would otherwise run three times —
     // field validation (inside resolveCreateInputs), the body build, and the

package/dist/commands/profile.d.ts

@@ -44,3 +44,23 @@ export declare function runProfileList(): Promise<ProfileListReport>;
 export declare function runProfileUse(name: string): Promise<void>;
 export declare function runProfileAdd(name: string): Promise<void>;
 export declare function runProfileRemove(name: string, force: boolean): Promise<void>;
+export interface ProfilePinOptions {
+    global?: boolean;
+    show?: boolean;
+}
+export interface ProfileUnpinOptions {
+    global?: boolean;
+}
+/**
+ * `el-linear profile pin [name]` — pin the current git repo to a Linear
+ * profile. Default target is the repo-local `.el-git.json`; `--global` writes
+ * the `owner/repo` entry into the shared global table. `--show` reports the
+ * resolved pin without writing.
+ */
+export declare function runProfilePin(name: string | undefined, opts: ProfilePinOptions): Promise<void>;
+/**
+ * `el-linear profile unpin` — remove the repo-local pin, or the exact global
+ * owner/repo mapping with `--global`. Preserves sibling keys and wildcard
+ * mappings; deletes a config file only when the removed pin was its sole data.
+ */
+export declare function runProfileUnpin(opts?: ProfileUnpinOptions): Promise<void>;

package/dist/commands/profile.js

@@ -23,7 +23,9 @@
 import { promises as fsp } from "node:fs";
 import path from "node:path";
 import { confirm } from "@inquirer/prompts";
+import { atomicWrite, withFileLock } from "../auth/oauth-fs.js";
 import { ACTIVE_PROFILE_FILE, CONFIG_DIR, CONFIG_PATH, isSafeProfileName as isSafeName, PROFILES_DIR, profilePaths, readActiveProfileMarker, resolveActiveProfile, setActiveProfileForSession, TOKEN_PATH, } from "../config/paths.js";
+import { applyGlobalPin, applyRepoLocalPin, defaultRepoProfileOps, globalPinTablePath, LINEAR_PROFILE_REPO_FILE, removeGlobalPin, removeRepoLocalPin, resolveRepoLinearProfile, } from "../config/repo-profile.js";
 import { outputSuccess, outputWarning } from "../utils/output.js";
 import { runFullWizard } from "./init/index.js";
 import { registerMembersCommands } from "./profile/members.js";
@@ -75,6 +77,23 @@ export function setupProfileCommands(program) {
         .action(async (name, opts) => {
         await runProfileRemove(name, opts.force === true);
     });
+    // `el-linear profile pin [name]` — DEV-7277: pin the current git repo to a
+    // Linear profile so multi-workspace users stop defaulting to the wrong one.
+    profile
+        .command("pin [name]")
+        .description("Pin the current git repo to a Linear profile so writes target the right workspace. Writes .el-git.json at the repo root (shared with el-git/el-session); [name] defaults to the active profile.")
+        .option("--global", "pin via the global owner/repo table (~/.config/el-git/linear-profiles.json) instead of the repo-local .el-git.json")
+        .option("--show", "print the resolved pin + its source without writing anything")
+        .action(async (name, opts) => {
+        await runProfilePin(name, opts);
+    });
+    profile
+        .command("unpin")
+        .description("Remove this repo's pin. Defaults to .el-git.json; --global removes its exact owner/repo mapping from the user-level table.")
+        .option("--global", "remove the exact origin owner/repo entry from ~/.config/el-git/linear-profiles.json")
+        .action(async (opts) => {
+        await runProfileUnpin(opts);
+    });
     // `el-linear profile migrate-legacy` — registered alongside add/list/etc.
     // Lives in its own module so the multi-step migration logic stays
     // self-contained and unit-testable without dragging in the full
@@ -188,12 +207,141 @@ export async function runProfileRemove(name, force) {
     await fsp.rm(dir, { recursive: true, force: true });
     // If the just-removed profile was the active one, clear the marker
     // so subsequent invocations fall back to the default paths.
-    const active = resolveActiveProfile();
-    if (active.name === trimmed && (await pathExists(ACTIVE_PROFILE_FILE))) {
+    const activeMarker = readActiveProfileMarker();
+    if (activeMarker === trimmed && (await pathExists(ACTIVE_PROFILE_FILE))) {
         await fsp.rm(ACTIVE_PROFILE_FILE, { force: true });
     }
     outputSuccess({ data: { removed: trimmed, dir } });
 }
+async function readFileOrNull(p) {
+    try {
+        return await fsp.readFile(p, "utf8");
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+async function assertNotSymbolicLink(p) {
+    try {
+        if ((await fsp.lstat(p)).isSymbolicLink()) {
+            throw new Error(`Refusing to edit symbolic link ${p}. Replace it with a regular JSON file, then retry.`);
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        throw err;
+    }
+}
+/**
+ * `el-linear profile pin [name]` — pin the current git repo to a Linear
+ * profile. Default target is the repo-local `.el-git.json`; `--global` writes
+ * the `owner/repo` entry into the shared global table. `--show` reports the
+ * resolved pin without writing.
+ */
+export async function runProfilePin(name, opts) {
+    const ops = defaultRepoProfileOps();
+    const cwd = process.cwd();
+    const root = ops.repoRoot(cwd);
+    if (opts.show) {
+        const resolved = resolveRepoLinearProfile(cwd);
+        outputSuccess({
+            data: {
+                pinned: resolved?.profile ?? null,
+                source: resolved?.source ?? null,
+                repoRoot: root,
+                originFullpath: ops.originFullpath(cwd),
+            },
+        });
+        return;
+    }
+    if (!root) {
+        throw new Error("Not in a git repository. `profile pin` writes a repo-scoped pin and needs a git repo (run it inside the repo you want to pin).");
+    }
+    // Default to the active profile when no name is given.
+    const target = (name ?? resolveActiveProfile().name ?? "").trim();
+    if (!target) {
+        throw new Error("No profile name given and no active profile is set (legacy single-profile default). Pass a name explicitly: `el-linear profile pin <name>`.");
+    }
+    if (!isSafeName(target)) {
+        throw new Error(`Profile name "${target}" must contain only [a-z0-9_-]. Pick a different name.`);
+    }
+    if (opts.global) {
+        const fullpath = ops.originFullpath(cwd);
+        if (!fullpath) {
+            throw new Error("Cannot determine the origin owner/repo for a global pin. Add an `origin` remote, or drop --global to write a repo-local .el-git.json instead.");
+        }
+        const file = globalPinTablePath();
+        await fsp.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+        await withFileLock(file, async () => {
+            const next = applyGlobalPin(await readFileOrNull(file), fullpath, target);
+            await atomicWrite(file, next, 0o644);
+        });
+        outputSuccess({
+            data: { scope: "global", key: fullpath, profile: target, file },
+        });
+        return;
+    }
+    const file = path.join(root, LINEAR_PROFILE_REPO_FILE);
+    await withFileLock(file, async () => {
+        await assertNotSymbolicLink(file);
+        const next = applyRepoLocalPin(await readFileOrNull(file), target);
+        await atomicWrite(file, next, 0o644);
+    });
+    outputSuccess({ data: { scope: "repo", profile: target, file } });
+}
+/**
+ * `el-linear profile unpin` — remove the repo-local pin, or the exact global
+ * owner/repo mapping with `--global`. Preserves sibling keys and wildcard
+ * mappings; deletes a config file only when the removed pin was its sole data.
+ */
+export async function runProfileUnpin(opts = {}) {
+    const ops = defaultRepoProfileOps();
+    const cwd = process.cwd();
+    const root = ops.repoRoot(cwd);
+    if (!root) {
+        throw new Error("Not in a git repository. `profile unpin` operates on the repo-local .el-git.json.");
+    }
+    if (opts.global) {
+        const fullpath = ops.originFullpath(cwd);
+        if (!fullpath) {
+            throw new Error("Cannot determine the origin owner/repo for a global unpin. Add an `origin` remote, or drop --global to remove the repo-local .el-git.json pin.");
+        }
+        const file = globalPinTablePath();
+        await fsp.mkdir(path.dirname(file), { recursive: true, mode: 0o700 });
+        await withFileLock(file, async () => {
+            const existing = await readFileOrNull(file);
+            const next = removeGlobalPin(existing, fullpath);
+            if (next === null) {
+                if (existing !== null)
+                    await fsp.rm(file, { force: true });
+            }
+            else if (next !== existing) {
+                await atomicWrite(file, next, 0o644);
+            }
+        });
+        outputSuccess({
+            data: { scope: "global", key: fullpath, unpinned: true, file },
+        });
+        return;
+    }
+    const file = path.join(root, LINEAR_PROFILE_REPO_FILE);
+    await withFileLock(file, async () => {
+        await assertNotSymbolicLink(file);
+        const existing = await readFileOrNull(file);
+        const next = removeRepoLocalPin(existing);
+        if (next === null) {
+            if (existing !== null)
+                await fsp.rm(file, { force: true });
+        }
+        else if (next !== existing) {
+            await atomicWrite(file, next, 0o644);
+        }
+    });
+    outputSuccess({ data: { scope: "repo", unpinned: true, file } });
+}
 // ---- Helpers ------------------------------------------------------------
 async function pathExists(p) {
     try {

package/dist/commands/projects.js

@@ -280,6 +280,11 @@ function flattenProjectUpdate(projectUpdate) {
         name: updatedProject.name,
         description: updatedProject.description ?? undefined,
         content: updatedProject.content ?? undefined,
+        // `?.` guards test fixtures/older callers whose mocked response omits
+        // the field — real API responses always carry it.
+        status: updatedProject.status?.name,
+        progress: updatedProject.progress,
+        url: updatedProject.url,
         teams: updatedProject.teams.nodes.map((t) => ({
             id: t.id,
             key: t.key,
@@ -515,13 +520,25 @@ async function handleUpdateProject(projectNameOrId, options, command) {
     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, --content, or --content-file.");
+    // --status resolves through a name lookup (network), unlike the other
+    // flags above — checked here only for the "nothing to update" guard so a
+    // bare `--status` still counts as work to do before we've made any calls.
+    const hasStatus = hasOption(options, "status");
+    if (Object.keys(input).length === 0 && !hasStatus) {
+        throw new Error("Nothing to update. Pass at least one of --name, --description, --content, --content-file, or --status.");
     }
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
     const linearService = await createLinearService(rootOpts);
     const projectId = await linearService.resolveProjectId(projectNameOrId);
+    if (hasStatus) {
+        // DEV-7021: resolves the workspace's configured project statuses by
+        // name (case-insensitive) and throws a "Project status ... not found"
+        // error listing the valid names on a miss — see
+        // `LinearService.resolveProjectStatusId` for why this can't be a
+        // static enum the way `VALID_PROJECT_STATES` is.
+        input.statusId = await linearService.resolveProjectStatusId(options.status);
+    }
     const updateResult = await graphQLService.rawRequest(UPDATE_PROJECT_FIELDS_MUTATION, { id: projectId, input });
     const projectUpdate = updateResult.projectUpdate;
     if (!projectUpdate.success) {
@@ -558,11 +575,13 @@ export function setupProjectsCommands(program) {
         .action(handleAsyncCommand(handleReadProject));
     projects
         .command("update <project>")
-        .description("Update project name, short description, or markdown content")
+        .description("Update project name, short description, markdown content, or status")
         .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")
+        .option("--status <name>", "project status name (case-insensitive; workspace-configured, e.g. Backlog, Planned, In Progress, Completed, Canceled) — lists valid statuses on a miss")
+        .option("-q, --quiet", "print one confirmation line (name, status, url) instead of the full JSON")
         .action(handleAsyncCommand(handleUpdateProject));
     projects
         .command("list")

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

@@ -10,6 +10,14 @@
  * 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"`.
+ *
+ * DEV-7074: the parser accepts the markdown an author actually types — any
+ * list marker (`-`, `*`, `+`, `1.`) and bolded or italicized labels with the
+ * colon inside (`**Needed:**`) or outside (`**Needed**:`) the emphasis run.
+ * When a field genuinely fails, the diagnostic names WHICH failure it is:
+ * an unreadable line, an absent field, an empty value, a placeholder, or a
+ * present-but-unjudged value. Reporting a formatting mismatch as empty content
+ * sent authors to rewrite prose that was already correct.
  */
 export declare const DEFAULT_INTAKE_SECTION_HEADERS: string[];
 export type IntakeDecisionGateMode = "off" | "warn" | "block";
@@ -18,6 +26,13 @@ export interface IntakeDecisionGateConfig {
     headers: string[];
 }
 export declare function getIntakeDecisionGateConfig(): IntakeDecisionGateConfig;
+/**
+ * What is actually wrong with a field whose label parsed. Keeping these apart
+ * matters: "the label didn't parse" and "the value is weak" send the author to
+ * completely different fixes, and reporting the first as the second sends them
+ * to rewrite prose that was already correct (DEV-7074).
+ */
+export type IntakeFieldProblem = "empty" | "placeholder" | "non-specific" | "no-judgment" | "placeholder-reason";
 export type IntakeDecisionEvaluation = {
     ok: true;
     header: string;
@@ -28,6 +43,11 @@ export type IntakeDecisionEvaluation = {
     ok: false;
     reason: "missing-field";
     field: string;
+} | {
+    ok: false;
+    reason: "unparsed-field";
+    field: string;
+    line: string;
 } | {
     ok: false;
     reason: "duplicate-field";
@@ -40,6 +60,8 @@ export type IntakeDecisionEvaluation = {
     ok: false;
     reason: "invalid-field";
     field: string;
+    problem: IntakeFieldProblem;
+    value: string;
 } | {
     ok: false;
     reason: "not-proceeding";