@enrichlayer/el-linear 1.37.0 → 1.37.2

package/README.md

@@ -145,6 +145,16 @@ EL_LINEAR_PROFILE=forage el-linear teams list
 el-linear profile remove old-profile
 ```
 
+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):
+
+```bash
+el-linear profile members list                              # show configured members
+el-linear profile members clear "linear"                     # remove a mistaken/stale entry
+el-linear profile members set "Alice Anderson" --aliases ali,al,alex
+```
+
 Each profile lives at `~/.config/el-linear/profiles/<name>/` and owns:
 
 - `token` — its Linear API token (mode 0600)
@@ -160,6 +170,18 @@ The active profile is selected by, in priority:
 The legacy fallback means **existing single-profile users see no
 behavior change** — profiles are purely opt-in.
 
+**Automation and concurrent sessions: prefer `--profile`/`$EL_LINEAR_PROFILE`
+over `profile use`.** `~/.config/el-linear/active-profile` is a single,
+machine-global marker file — `profile use <name>` mutates it for *every*
+el-linear invocation on the machine, including other terminals, scripts, and
+agent sessions that don't set an explicit override. Two processes wanting
+different workspaces at the same time will silently clobber each other. The
+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.
+
 ## Migrating from v1.0–1.3
 
 Versions 1.0–1.3 stored everything in the single-file layout
@@ -454,7 +476,7 @@ el-linear <command> --help       # detailed help for one command
 | Search | `search <query>` (semantic, cross-resource) |
 | Refs | `refs wrap` (rewrite issue identifiers in arbitrary text as links) |
 | Escape hatch | `graphql [query]` (with `--introspect`) |
-| Config | `config show`, `users list`, `teams list`, `templates list` |
+| Config | `config show`, `users {list, read}`, `teams list`, `templates list` |
 
 All `list` subcommands support `-l, --limit <n>`. All commands accept the
 top-level filters: `--format <json|summary>`, `--raw`, `--jq <expr>`, `--fields <list>`.

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

@@ -241,11 +241,10 @@ el-linear issues search "keywords from proposed title" --include-closed 2>&1
 
 The dup-check above guards against duplicating an *issue*. This guards against duplicating *reality*: before filing an issue to **add** a flag / guard / command / subcommand, confirm it doesn't **already exist**.
 
-- `<cli> <subcommand> --help` (the flag may be a global option absent from the subcommand's help — check `<cli> --help` too).
-- `el-catalog commands --search "<intent>"` / `el-catalog clis --search` (the snapshot likely already lists it).
-- For a hook/guard, grep the source — e.g. `cli/el-hook/src/checks`.
+- **`el-catalog commands --search "<intent>"`** / `el-catalog clis --search` — the **authoritative** check for a command/subcommand; it deterministically indexes every `<cli> <subcommand>`. Confirm with `<cli> <subcommand> --help` (and `<cli> --help` — a flag may be a global option absent from the subcommand's help).
+- For a hook/guard, grep the source (e.g. `cli/el-hook/src/checks`) — but **empty grep output is inconclusive, not proof of absence**. A mis-quoted glob or bad flag makes grep exit silently with zero matches (`grep --include=*.ts …` errors under zsh, returning nothing for a symbol that exists). Never read a raw grep's silence as "doesn't exist" for the command check — that is exactly what `el-catalog` is for.
 
-Skipping it cost two needless branch+MR cycles in one session: a "feature" issue to add a hook guard that already existed and was firing, and one to add `--jq`/`--fields` flags that already worked — both premises only caught at implementation.
+Skipping it cost real rework across sessions: a hook guard and `--jq`/`--fields` flags filed as "features" though both already existed and worked, and a near-duplicate `el-git` subcommand built after a raw grep silently misfired (the `el-catalog` search would have found the existing one) — every premise caught only at implementation.
 
 When `el-linear issues search` (or the cross-resource `search`) returns rows
 carrying issue identifiers, the JSON envelope embeds a `_warnings` line

package/dist/commands/init/aliases.d.ts

@@ -17,6 +17,17 @@ export interface User {
     displayName: string;
 }
 export declare function fetchAllUsers(token: string): Promise<User[]>;
+/**
+ * Detect the synthetic Linear-internal "system actor" surfaced by the Users
+ * API alongside real people — DEV-5612. Its email is a
+ * `<uuid>@linear.linear.app` address (the documented pattern for Linear's own
+ * automation account); it isn't a person and should never be offered as an
+ * assignable alias target. A user setting up the alias wizard for the first
+ * time mistook it for themselves (`linear <linear-…@linear.linear.app>`
+ * presented as an ordinary numbered member) and typed their own nicknames as
+ * its aliases.
+ */
+export declare function isLinearSystemActor(user: User): boolean;
 /**
  * Find groups of users sharing the same display name. The current alias
  * config keys aliases by display name, so colliding users would silently
@@ -25,11 +36,29 @@ export declare function fetchAllUsers(token: string): Promise<User[]>;
  * schema to UUID-keyed maps.
  */
 export declare function findDisplayNameCollisions(users: User[]): Map<string, User[]>;
+/** The alias/handle-mutation slice of {@link AliasUpdate}, without the user
+ * identity fields — shared by the UUID-keyed wizard merge and the by-name
+ * direct-edit path (DEV-5612), which has no UUID to record. */
+export type MemberAliasMutation = Pick<AliasUpdate, "mode" | "aliases" | "github" | "gitlab">;
 /**
  * Merge new alias entries into existing config without dropping unrelated
  * fields. Pure function — no I/O. Exported for testing.
  */
 export declare function mergeAliasesIntoConfig(existing: WizardConfig, updates: Map<string, AliasUpdate>): WizardConfig;
+/**
+ * Apply a single member alias/handle mutation directly by display name — the
+ * non-interactive counterpart to the `init aliases` walk (DEV-5612). Used by
+ * `el-linear profile members clear <name>` / `members set <name>` so a
+ * mistaken or unwanted entry (e.g. the Linear system actor, or a stale
+ * alias) can be fixed without hand-editing config.json or re-walking every
+ * user interactively.
+ *
+ * Unlike {@link mergeAliasesIntoConfig} (keyed by Linear user UUID, populated
+ * by the `init aliases` walk against the live Users API), this operates
+ * purely on the on-disk config by display name — the `uuids`/`fullNames`
+ * maps are left untouched since there's no fresh UUID to record here.
+ */
+export declare function applyMemberAliasUpdate(existing: WizardConfig, displayName: string, update: MemberAliasMutation): WizardConfig;
 /**
  * What to do with a single platform handle (github/gitlab/...) when applying
  * an AliasUpdate. Discriminated union; no sentinel strings.

package/dist/commands/init/aliases.js

@@ -46,6 +46,19 @@ export async function fetchAllUsers(token) {
     }
     return out;
 }
+/**
+ * Detect the synthetic Linear-internal "system actor" surfaced by the Users
+ * API alongside real people — DEV-5612. Its email is a
+ * `<uuid>@linear.linear.app` address (the documented pattern for Linear's own
+ * automation account); it isn't a person and should never be offered as an
+ * assignable alias target. A user setting up the alias wizard for the first
+ * time mistook it for themselves (`linear <linear-…@linear.linear.app>`
+ * presented as an ordinary numbered member) and typed their own nicknames as
+ * its aliases.
+ */
+export function isLinearSystemActor(user) {
+    return Boolean(user.email && /@linear\.linear\.app$/i.test(user.email));
+}
 /**
  * Find groups of users sharing the same display name. The current alias
  * config keys aliases by display name, so colliding users would silently
@@ -82,6 +95,45 @@ function applyHandleAction(handlesMap, fullName, action) {
         handlesMap[action.value.trim()] = fullName;
     }
 }
+/**
+ * Apply one member's alias/handle mutation into `next` (mutated in place).
+ * Ensures the `members.aliases`/`members.handles.{github,gitlab}` sub-trees
+ * exist first. Pure with respect to `fullName`/`update` — the only side
+ * effect is on `next`.
+ */
+function applyAliasMutation(next, fullName, update) {
+    next.members = next.members ?? {};
+    next.members.aliases = next.members.aliases ?? {};
+    next.members.handles = next.members.handles ?? {};
+    next.members.handles.github = next.members.handles.github ?? {};
+    next.members.handles.gitlab = next.members.handles.gitlab ?? {};
+    // Aliases: replace this user's entries based on the update mode.
+    // We track aliases as { aliasKey: fullName }, so removing means deleting
+    // any keys whose value is this fullName.
+    const currentAliasKeys = Object.entries(next.members.aliases)
+        .filter(([_, v]) => v === fullName)
+        .map(([k]) => k);
+    if (update.mode === "clear") {
+        for (const k of currentAliasKeys)
+            delete next.members.aliases[k];
+    }
+    else if (update.mode === "edit") {
+        for (const k of currentAliasKeys)
+            delete next.members.aliases[k];
+        for (const a of update.aliases)
+            next.members.aliases[a] = fullName;
+    }
+    else if (update.mode === "append") {
+        for (const a of update.aliases)
+            next.members.aliases[a] = fullName;
+    }
+    // "keep" → no changes.
+    // GitHub / GitLab handles use the same edit/append/clear semantics,
+    // driven by the discriminated HandleAction per platform.
+    for (const platform of HANDLE_PLATFORMS) {
+        applyHandleAction(next.members.handles[platform], fullName, update[platform]);
+    }
+}
 /**
  * Merge new alias entries into existing config without dropping unrelated
  * fields. Pure function — no I/O. Exported for testing.
@@ -89,45 +141,34 @@ function applyHandleAction(handlesMap, fullName, action) {
 export function mergeAliasesIntoConfig(existing, updates) {
     const next = JSON.parse(JSON.stringify(existing));
     next.members = next.members ?? {};
-    next.members.aliases = next.members.aliases ?? {};
     next.members.fullNames = next.members.fullNames ?? {};
-    next.members.handles = next.members.handles ?? {};
     next.members.uuids = next.members.uuids ?? {};
-    next.members.handles.github = next.members.handles.github ?? {};
-    next.members.handles.gitlab = next.members.handles.gitlab ?? {};
     for (const [userId, update] of updates) {
         const fullName = update.displayName;
         next.members.uuids[fullName] = userId;
         next.members.fullNames[userId] = fullName;
-        // Aliases: replace this user's entries based on the update mode.
-        // We track aliases as { aliasKey: fullName }, so removing means deleting
-        // any keys whose value is this fullName.
-        const currentAliasKeys = Object.entries(next.members.aliases)
-            .filter(([_, v]) => v === fullName)
-            .map(([k]) => k);
-        if (update.mode === "clear") {
-            for (const k of currentAliasKeys)
-                delete next.members.aliases[k];
-        }
-        else if (update.mode === "edit") {
-            for (const k of currentAliasKeys)
-                delete next.members.aliases[k];
-            for (const a of update.aliases)
-                next.members.aliases[a] = fullName;
-        }
-        else if (update.mode === "append") {
-            for (const a of update.aliases)
-                next.members.aliases[a] = fullName;
-        }
-        // "keep" → no changes.
-        // GitHub / GitLab handles use the same edit/append/clear semantics,
-        // driven by the discriminated HandleAction per platform.
-        for (const platform of HANDLE_PLATFORMS) {
-            applyHandleAction(next.members.handles[platform], fullName, update[platform]);
-        }
+        applyAliasMutation(next, fullName, update);
     }
     return next;
 }
+/**
+ * Apply a single member alias/handle mutation directly by display name — the
+ * non-interactive counterpart to the `init aliases` walk (DEV-5612). Used by
+ * `el-linear profile members clear <name>` / `members set <name>` so a
+ * mistaken or unwanted entry (e.g. the Linear system actor, or a stale
+ * alias) can be fixed without hand-editing config.json or re-walking every
+ * user interactively.
+ *
+ * Unlike {@link mergeAliasesIntoConfig} (keyed by Linear user UUID, populated
+ * by the `init aliases` walk against the live Users API), this operates
+ * purely on the on-disk config by display name — the `uuids`/`fullNames`
+ * maps are left untouched since there's no fresh UUID to record here.
+ */
+export function applyMemberAliasUpdate(existing, displayName, update) {
+    const next = JSON.parse(JSON.stringify(existing));
+    applyAliasMutation(next, displayName, update);
+    return next;
+}
 /** Set of supported platforms for member handle keys. */
 export const HANDLE_PLATFORMS = ["github", "gitlab"];
 function currentAliasesFor(config, fullName) {
@@ -162,11 +203,24 @@ export async function runAliasesStep(token, existing, options = {}) {
         console.log("  Skipped — run `el-linear init aliases` to add or edit aliases later.");
         return new Map();
     }
-    const allUsers = await fetchAllUsers(token);
-    if (allUsers.length === 0) {
+    const fetchedUsers = await fetchAllUsers(token);
+    if (fetchedUsers.length === 0) {
         console.log("  No active users visible to this token.");
         return new Map();
     }
+    // Skip the Linear system actor(s) — not real people, never alias targets
+    // (DEV-5612). Filtered before collision detection so it can't spuriously
+    // collide with (or mask) a real display-name collision.
+    const systemActors = fetchedUsers.filter(isLinearSystemActor);
+    if (systemActors.length > 0) {
+        console.log(`  Skipping ${systemActors.length} Linear system actor(s) — not real people, never alias targets: ` +
+            `${systemActors.map((u) => u.email ?? u.id).join(", ")}`);
+    }
+    const allUsers = fetchedUsers.filter((u) => !isLinearSystemActor(u));
+    if (allUsers.length === 0) {
+        console.log("  No human users remain after filtering system actors.");
+        return new Map();
+    }
     // Skip users whose display name collides with another active user. The
     // current schema keys aliases by display name, so writing aliases for a
     // colliding user would corrupt the other user's entries. A schema migration

package/dist/commands/issues.js

@@ -7,7 +7,7 @@ import { formatSopParentBlock, getSopLabelGateConfig, hasSopLabel, isUnresolvabl
 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";
-import { DEFAULT_DUPLICATE_THRESHOLD, formatDuplicateBlock, scoreDuplicateCandidates, tokenizeTitle, } from "../utils/duplicate-detection.js";
+import { DEFAULT_DUPLICATE_THRESHOLD, DEFAULT_HARD_BLOCK_THRESHOLD, formatDuplicateBlock, scoreDuplicateCandidates, tokenizeTitle, } from "../utils/duplicate-detection.js";
 import { createFileService } from "../utils/file-service.js";
 import { applyFooter } from "../utils/footer.js";
 import { emitGateEvent } from "../utils/gate-telemetry.js";
@@ -18,7 +18,7 @@ import { createLinearService, } from "../utils/linear-service.js";
 import { logger } from "../utils/logger.js";
 import { handleAsyncCommand, outputSuccess, outputWarning, warnIfTruncated, } from "../utils/output.js";
 import { buildRelationCandidatePrompt } from "../utils/relation-candidate-prompt.js";
-import { getRootOpts } from "../utils/root-opts.js";
+import { effectiveOption, getRootOpts } from "../utils/root-opts.js";
 import { formatCsv, formatMarkdown, formatTable, } from "../utils/table-formatter.js";
 import { parsePositiveInt, parsePriorityFilter, splitList, validatePriority, } from "../utils/validators.js";
 import { currentGitBranch, extractIssueIdentifierFromBranch, getBranchLinearIssue, gitCheckoutBranch, setBranchLinearIssue, toBranchName, } from "./issues/branch.js";
@@ -121,7 +121,17 @@ function buildUpdateArgs(issueId, options, assigneeId, delegateId) {
         dueDate: options.dueDate || (options.clearDueDate ? null : undefined),
     };
 }
-function outputIssues(issues, format, fields, meta) {
+/**
+ * `--format` / `--fields` are registered on both the root program and the
+ * list/search subcommands, and commander 15 assigns the CLI token to the
+ * root registration — so the values must be resolved via
+ * {@link effectiveOption} rather than read off the subcommand's own
+ * options (DEV-5376: `--format table --fields …` silently fell through to
+ * the JSON envelope because `options.format` stayed at its default).
+ */
+function outputIssues(issues, command, meta) {
+    const format = effectiveOption(command, "format");
+    const fields = effectiveOption(command, "fields");
     const fieldList = fields ? splitList(fields) : undefined;
     if (format === "table") {
         logger.info(formatTable(issues, fieldList));
@@ -134,6 +144,13 @@ function outputIssues(issues, format, fields, meta) {
         logger.info(formatCsv(issues, fieldList));
     }
     else {
+        // JSON path: the `--fields` projection is applied by the global
+        // `fieldsFilter` inside `outputSuccess` (set in main.ts's preAction),
+        // NOT by `fieldList` here — `fieldList` only feeds the tabular
+        // formatters above. Keeping the projection in one place is what
+        // prevents double-application; a future refactor that routes
+        // table/csv/md through `outputSuccess` would need to drop the global
+        // filter or it would project twice.
         outputSuccess({ data: issues, meta: { count: issues.length, ...meta } });
     }
 }
@@ -228,14 +245,14 @@ async function handleListIssues(options, command) {
             outputWarning("excluded terminal states (Done / Canceled) by default; pass --include-closed to include them");
         }
         warnIfTruncated(result.length, limit);
-        outputIssues(result, options.format, options.fields, {
+        outputIssues(result, command, {
             team: options.team,
         });
     }
     else {
         const result = sortIssues(await issuesService.getIssues(limit), options.sort);
         warnIfTruncated(result.length, limit);
-        outputIssues(result, options.format, options.fields, {});
+        outputIssues(result, command, {});
     }
 }
 async function handleSearchIssues(query, options, command) {
@@ -282,7 +299,7 @@ async function handleSearchIssues(query, options, command) {
     if (relationPrompt) {
         outputWarning(relationPrompt);
     }
-    outputIssues(result, options.format, options.fields, { query });
+    outputIssues(result, command, { query });
 }
 /**
  * Run an `issuesService.createIssue` / `.updateIssue` call and, if it
@@ -460,18 +477,28 @@ function buildDescriptionWithAttachments(baseDescription, uploadResults) {
 /**
  * DEV-4823: create-time duplicate-detection gate. Searches the title's
  * salient keywords (including closed issues), scores candidates by Jaccard
- * title-overlap, and throws — listing the matches — when one is at/above the
- * configured similarity threshold.
+ * title-overlap, and — for a candidate at/above the hard-block threshold —
+ * throws, listing the matches.
+ *
+ * DEV-5590: two-tier since the single-threshold gate measured a 52.2%
+ * override rate (score alone didn't separate genuine duplicates from
+ * legitimate distinct issues — see {@link DEFAULT_HARD_BLOCK_THRESHOLD} for
+ * the data). A candidate at/above `duplicateThreshold` (detection floor) but
+ * below `duplicateHardBlockThreshold` (hard-block floor) is ADVISORY: printed
+ * as a warning, creation proceeds, and the fire is recorded as `advisory` —
+ * excluded from the override-rate denominator (only `blocked`/`overridden`
+ * count). At/above the hard-block floor, behavior is unchanged from DEV-4823.
  *
  * Bypassed by `--skip-validation` and
  * `config.validation.duplicateDetection: false` / `validation.enabled: false`.
  * `--allow-duplicate` does NOT skip the search — the gate still runs and, on a
- * would-fire, records an `overridden` telemetry event (DEV-4834) before
- * proceeding, so `el-telemetry gates` can measure the override-rate. (A blocked
- * fire records `blocked`.) `--skip-validation` is a blanket bypass and emits
- * nothing — it's not a gate-specific override, so counting it would dilute the
- * signal. The search itself is best-effort: a network/API failure warns and
- * proceeds rather than blocking legitimate issue creation on infra trouble.
+ * would-hard-block, records an `overridden` telemetry event (DEV-4834) before
+ * proceeding, so `el-telemetry gates` can measure the override-rate. (A
+ * hard-blocked fire records `blocked`.) `--skip-validation` is a blanket
+ * bypass and emits nothing — it's not a gate-specific override, so counting
+ * it would dilute the signal. The search itself is best-effort: a network/API
+ * failure warns and proceeds rather than blocking legitimate issue creation
+ * on infra trouble.
  */
 async function enforceNoDuplicateIssue(title, options, issuesService) {
     if (options.skipValidation) {
@@ -492,6 +519,9 @@ async function enforceNoDuplicateIssue(title, options, issuesService) {
     const threshold = typeof validation?.duplicateThreshold === "number"
         ? validation.duplicateThreshold
         : DEFAULT_DUPLICATE_THRESHOLD;
+    const hardBlockThreshold = typeof validation?.duplicateHardBlockThreshold === "number"
+        ? validation.duplicateHardBlockThreshold
+        : DEFAULT_HARD_BLOCK_THRESHOLD;
     let candidates;
     try {
         candidates = await issuesService.searchIssues({
@@ -524,14 +554,25 @@ async function enforceNoDuplicateIssue(title, options, issuesService) {
     if (matches.length === 0) {
         return;
     }
-    // The gate would fire. Record the decision so `el-telemetry gates` can
-    // compute override-rate (DEV-4834): `overridden` when the user passed
-    // --allow-duplicate and we proceed anyway, `blocked` when we stop creation.
     const gateEvent = {
         gate: "issues-create-dup",
         topScore: matches[0].score,
         candidateCount: matches.length,
     };
+    // DEV-5590: below the hard-block floor, warn and proceed — never forces a
+    // stop, so there's nothing to "override". Recorded as `advisory` (visible
+    // in the raw ledger, excluded from the override-rate metric).
+    if (matches[0].score < hardBlockThreshold) {
+        await emitGateEvent("el-linear", "issues create", {
+            ...gateEvent,
+            outcome: "advisory",
+        });
+        outputWarning(formatDuplicateBlock(matches, "advisory"));
+        return;
+    }
+    // The gate would hard-block. Record the decision so `el-telemetry gates`
+    // can compute override-rate (DEV-4834): `overridden` when the user passed
+    // --allow-duplicate and we proceed anyway, `blocked` when we stop creation.
     if (options.allowDuplicate) {
         await emitGateEvent("el-linear", "issues create", {
             ...gateEvent,
@@ -1251,7 +1292,7 @@ export function setupIssuesCommands(program) {
         .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)")
-        .option("--allow-duplicate", "skip the duplicate-detection gate and create even if a similar issue already exists")
+        .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("--no-auto-link", "skip auto-linking issue references found in the description")
         .option("--footer <text>", "text appended to the description (overrides config.messageFooter)")

package/dist/commands/profile/members.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `el-linear profile members` — direct, non-interactive alias/handle edits
+ * on the active profile's on-disk config — DEV-5612.
+ *
+ * `init aliases` (the interactive wizard walk) is the right tool for a
+ * first-time setup or a bulk pass over many users, but fixing ONE entry
+ * (e.g. clearing a mistaken alias, or the Linear system actor a user
+ * accidentally aliased before DEV-5612's wizard-side skip existed) meant
+ * either re-walking every user interactively or hand-editing
+ * `~/.config/el-linear/config.json`. These commands are the direct path:
+ *
+ *   el-linear profile members list                      — show configured members
+ *   el-linear profile members clear <name>               — remove all aliases/handles for <name>
+ *   el-linear profile members set <name> [options]        — replace aliases/handles for <name>
+ *
+ * `<name>` is the exact Linear display name as it appears in
+ * `members.aliases`/`members.handles.*` values (see `profile members list`).
+ * These commands operate purely on the local config file — no Linear API
+ * call, no UUID resolution — so they also work to clean up a stale/mistaken
+ * entry for a user no longer in the workspace.
+ */
+import type { Command } from "commander";
+import { type WizardConfig } from "../init/shared.js";
+export interface MemberListEntry {
+    displayName: string;
+    aliases: string[];
+    github?: string;
+    gitlab?: string;
+}
+/**
+ * Reconstruct a per-member view from the on-disk `members.aliases` /
+ * `members.handles.{github,gitlab}` maps (each `{ key: displayName }`).
+ * `WizardConfig`'s maps are `Record<string, string | undefined>` (DeepPartial
+ * over an index signature) — an `undefined` value can't happen in practice
+ * (JSON never round-trips one), but we guard it defensively rather than cast.
+ * Pure — exported for testing.
+ */
+export declare function listMembers(config: WizardConfig): MemberListEntry[];
+/** `el-linear profile members list` — exported for direct testing. */
+export declare function runMembersList(): Promise<MemberListEntry[]>;
+/** `el-linear profile members clear <name>` — exported for direct testing. */
+export declare function runMembersClear(name: string): Promise<void>;
+export interface MembersSetOptions {
+    aliases?: string;
+    github?: string;
+    gitlab?: string;
+}
+/** `el-linear profile members set <name>` — exported for direct testing. */
+export declare function runMembersSet(name: string, opts: MembersSetOptions): Promise<void>;
+export declare function registerMembersCommands(profile: Command): void;

package/dist/commands/profile/members.js

@@ -0,0 +1,132 @@
+/**
+ * `el-linear profile members` — direct, non-interactive alias/handle edits
+ * on the active profile's on-disk config — DEV-5612.
+ *
+ * `init aliases` (the interactive wizard walk) is the right tool for a
+ * first-time setup or a bulk pass over many users, but fixing ONE entry
+ * (e.g. clearing a mistaken alias, or the Linear system actor a user
+ * accidentally aliased before DEV-5612's wizard-side skip existed) meant
+ * either re-walking every user interactively or hand-editing
+ * `~/.config/el-linear/config.json`. These commands are the direct path:
+ *
+ *   el-linear profile members list                      — show configured members
+ *   el-linear profile members clear <name>               — remove all aliases/handles for <name>
+ *   el-linear profile members set <name> [options]        — replace aliases/handles for <name>
+ *
+ * `<name>` is the exact Linear display name as it appears in
+ * `members.aliases`/`members.handles.*` values (see `profile members list`).
+ * These commands operate purely on the local config file — no Linear API
+ * call, no UUID resolution — so they also work to clean up a stale/mistaken
+ * entry for a user no longer in the workspace.
+ */
+import { outputSuccess } from "../../utils/output.js";
+import { applyMemberAliasUpdate } from "../init/aliases.js";
+import { parseCsvList, readConfig, updateConfig, } from "../init/shared.js";
+/**
+ * Reconstruct a per-member view from the on-disk `members.aliases` /
+ * `members.handles.{github,gitlab}` maps (each `{ key: displayName }`).
+ * `WizardConfig`'s maps are `Record<string, string | undefined>` (DeepPartial
+ * over an index signature) — an `undefined` value can't happen in practice
+ * (JSON never round-trips one), but we guard it defensively rather than cast.
+ * Pure — exported for testing.
+ */
+export function listMembers(config) {
+    const aliases = config.members?.aliases ?? {};
+    const github = config.members?.handles?.github ?? {};
+    const gitlab = config.members?.handles?.gitlab ?? {};
+    const byName = new Map();
+    const ensure = (name) => {
+        let entry = byName.get(name);
+        if (!entry) {
+            entry = { displayName: name, aliases: [] };
+            byName.set(name, entry);
+        }
+        return entry;
+    };
+    for (const [alias, name] of Object.entries(aliases)) {
+        if (name === undefined)
+            continue;
+        ensure(name).aliases.push(alias);
+    }
+    for (const [handle, name] of Object.entries(github)) {
+        if (name === undefined)
+            continue;
+        ensure(name).github = handle;
+    }
+    for (const [handle, name] of Object.entries(gitlab)) {
+        if (name === undefined)
+            continue;
+        ensure(name).gitlab = handle;
+    }
+    return [...byName.values()].sort((a, b) => a.displayName.localeCompare(b.displayName));
+}
+/**
+ * Translate a `--github`/`--gitlab` flag value into a HandleAction:
+ *   - flag absent          → keep (leave any existing handle alone)
+ *   - flag present, empty  → clear
+ *   - flag present, value  → set
+ */
+function handleActionFromFlag(raw) {
+    if (raw === undefined)
+        return { kind: "keep" };
+    const trimmed = raw.trim();
+    return trimmed ? { kind: "set", value: trimmed } : { kind: "clear" };
+}
+/** `el-linear profile members list` — exported for direct testing. */
+export async function runMembersList() {
+    const config = await readConfig();
+    return listMembers(config);
+}
+/** `el-linear profile members clear <name>` — exported for direct testing. */
+export async function runMembersClear(name) {
+    await updateConfig((current) => applyMemberAliasUpdate(current, name, {
+        mode: "clear",
+        aliases: [],
+        github: { kind: "clear" },
+        gitlab: { kind: "clear" },
+    }));
+}
+/** `el-linear profile members set <name>` — exported for direct testing. */
+export async function runMembersSet(name, opts) {
+    if (opts.aliases === undefined &&
+        opts.github === undefined &&
+        opts.gitlab === undefined) {
+        throw new Error("Pass at least one of --aliases, --github, --gitlab.");
+    }
+    await updateConfig((current) => applyMemberAliasUpdate(current, name, {
+        mode: opts.aliases !== undefined ? "edit" : "keep",
+        aliases: opts.aliases !== undefined ? parseCsvList(opts.aliases) : [],
+        github: handleActionFromFlag(opts.github),
+        gitlab: handleActionFromFlag(opts.gitlab),
+    }));
+}
+export function registerMembersCommands(profile) {
+    const members = profile
+        .command("members")
+        .description("Directly edit or clear a member's aliases/handles without hand-editing config.json (DEV-5612).");
+    members.action(() => members.help());
+    members
+        .command("list")
+        .description("List members with configured aliases/GitHub/GitLab handles.")
+        .action(async () => {
+        const data = await runMembersList();
+        outputSuccess({ data, meta: { count: data.length } });
+    });
+    members
+        .command("clear <name>")
+        .description("Remove all aliases + GitHub/GitLab handles for <name> (exact display name, see `members list`).")
+        .action(async (name) => {
+        await runMembersClear(name);
+        outputSuccess({ data: { cleared: name } });
+    });
+    members
+        .command("set <name>")
+        .description("Replace aliases/handles for <name> (exact display name). Omit a flag to leave that field unchanged; pass an empty value to clear just that field.")
+        .option("--aliases <csv>", "comma-separated aliases; replaces the existing set for this member")
+        .option("--github <handle>", "GitHub handle; pass an empty string to clear")
+        .option("--gitlab <handle>", "GitLab handle; pass an empty string to clear")
+        .action(async (name, opts) => {
+        await runMembersSet(name, opts);
+        outputSuccess({ data: { updated: name } });
+    });
+}