@enrichlayer/el-linear 1.10.0 → 1.15.0

package/dist/commands/projects.js

@@ -5,7 +5,7 @@ import { cached, resolveCacheTTL } from "../utils/disk-cache.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { createLinearService } from "../utils/linear-service.js";
 import { logger } from "../utils/logger.js";
-import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { handleAsyncCommand, outputSuccess, outputWarning, } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { renderCsv, renderFixedWidthTable, renderMarkdownTable, } from "../utils/table-formatter.js";
 import { isUuid } from "../utils/uuid.js";
@@ -18,6 +18,58 @@ const VALID_PROJECT_STATES = new Set([
     "completed",
     "canceled",
 ]);
+/**
+ * Display ordering for `projects list`: active work first, terminal states
+ * last. Without this, the SDK's `updatedAt` order surfaces recently-touched
+ * completed/canceled projects ahead of in-progress ones — so an active project
+ * can fall past the `--limit` window and an agent concludes it does not exist
+ * (the DEV-4175 silent-truncation failure). Stable sort preserves `updatedAt`
+ * within each rank.
+ *
+ * `Linear` exposes additional internal states (e.g. archived) that we don't
+ * enumerate here; anything not in this table sorts to the end via
+ * `UNRANKED_STATE`.
+ */
+const PROJECT_STATE_RANK = {
+    started: 0,
+    planned: 1,
+    paused: 2,
+    backlog: 3,
+    completed: 4,
+    canceled: 5,
+};
+// Sentinel for any state Linear surfaces that isn't in the rank table above
+// (e.g. `archived`, future additions). Number.MAX_SAFE_INTEGER reads more
+// deliberately than a magic `9` and stays correct if PROJECT_STATE_RANK grows.
+const UNRANKED_STATE = Number.MAX_SAFE_INTEGER;
+export function sortActiveFirst(projects) {
+    return [...projects].sort((a, b) => (PROJECT_STATE_RANK[a.state ?? ""] ?? UNRANKED_STATE) -
+        (PROJECT_STATE_RANK[b.state ?? ""] ?? UNRANKED_STATE));
+}
+/**
+ * Emit a truncation warning when `projects list` returned exactly `--limit`
+ * rows (the same `count === limit` heuristic as `warnIfTruncated` in
+ * `output.ts`). JSON buffers it into `_warnings` so the payload stays a single
+ * parseable object; every human-facing format prints to stderr so it can't be
+ * silently scrolled past. DEV-4175.
+ *
+ * The exact total is deliberately omitted from the message. Returning it would
+ * require a second `client.projects({ first: 0 })` round-trip (the SDK has no
+ * `count`-only helper) or a full pagination walk — both negate the cheap-page
+ * default. `--all` in the hint gives the caller a deterministic way to learn
+ * the real total without us guessing, so the absence is a feature, not a gap.
+ */
+function warnProjectsTruncated(count, limit, format) {
+    const msg = `results_truncated: returned ${count} projects matching --limit ${limit}; ` +
+        "more may exist. Re-run with --all to fetch every project " +
+        `(or --limit ${limit * 2}, or narrow with --name / --state / --team).`;
+    if (format === "json") {
+        outputWarning(msg);
+    }
+    else {
+        logger.error(msg);
+    }
+}
 function parseStateList(value, flagName) {
     const states = splitList(value).map((s) => s.toLowerCase());
     for (const s of states) {
@@ -390,13 +442,22 @@ export function setupProjectsCommands(program) {
         .option("--format <format>", "output format (json, summary, table, md, csv)", "json")
         .option("--fields <fields>", "columns for table/csv (comma-separated: name,state,progress,teams,lead,targetDate)")
         .option("--name <substring>", "filter by case-insensitive substring on project name")
+        .option("--team <key|name>", "filter to projects belonging to a specific team (e.g. DEV, FE)")
         .option("--state <names>", "include only projects in these states (comma-separated: backlog, planned, started, paused, completed, canceled)")
         .option("--exclude-state <names>", "exclude projects in these states (comma-separated). Mutually exclusive with --state.")
         .option("--active", "shorthand for --exclude-state completed,canceled (mutually exclusive with --state / --exclude-state)")
+        .option("--all", "fetch every project (paginates fully). Equivalent to --limit 0; overrides --limit when both are given.")
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
-        const limit = parsePositiveInt(options.limit, "--limit");
+        // `--all` / `--limit 0` mean unlimited. Stored as `limit = 0`,
+        // which `LinearService.getProjects` interprets as "paginate
+        // fully". DEV-4175.
+        const unlimited = options.all === true || options.limit === "0";
+        const limit = unlimited
+            ? 0
+            : parsePositiveInt(options.limit, "--limit");
         const nameFilter = options.name;
+        const teamFilter = options.team;
         const stateFilter = resolveProjectStateFilter(options);
         const ttl = resolveCacheTTL({
             configTTL: loadConfig().cacheTTLSeconds,
@@ -406,31 +467,54 @@ export function setupProjectsCommands(program) {
         // don't collide.
         const cacheKey = `projects-list-limit:${limit}` +
             `-name:${nameFilter ?? "_all"}` +
+            `-team:${teamFilter ?? "_all"}` +
             `-states:${stateFilter.states?.join(",") ?? "_any"}` +
             `-excl:${stateFilter.excludeStates?.join(",") ?? "_none"}`;
         const result = await cached(cacheKey, ttl, async () => {
             const service = await createLinearService(rootOpts);
+            let teamId;
+            if (teamFilter) {
+                const resolved = resolveTeam(teamFilter);
+                teamId = await service.resolveTeamId(resolved);
+            }
             return service.getProjects(limit, {
                 nameFilter,
+                teamId,
                 states: stateFilter.states,
                 excludeStates: stateFilter.excludeStates,
             });
         });
+        // Active-first sort: keeps started/planned/paused/backlog
+        // ahead of completed/canceled in every format, so the active
+        // set always fits within `--limit`. DEV-4175.
+        const sorted = sortActiveFirst(result);
         const format = options.format;
-        if (format === "table" ||
+        const isTabular = format === "table" ||
             format === "md" ||
             format === "markdown" ||
-            format === "csv") {
+            format === "csv";
+        // Emit the truncation warning BEFORE outputting: the JSON
+        // branch buffers into `_warnings`, which the next
+        // `outputSuccess()` call drains. All other formats route to
+        // stderr via `logger.error` so the visible payload (table,
+        // markdown, summary) stays clean.
+        if (!unlimited && sorted.length === limit) {
+            warnProjectsTruncated(sorted.length, limit, format);
+        }
+        if (isTabular) {
             const fieldList = options.fields
                 ? splitList(options.fields)
                 : undefined;
-            formatProjectsOutput(result, format, fieldList);
+            formatProjectsOutput(sorted, format, fieldList);
             if (format === "table") {
-                logger.info(`\n${result.length} projects`);
+                logger.info(`\n${sorted.length} projects`);
             }
         }
         else {
-            outputSuccess({ data: result, meta: { count: result.length } });
+            outputSuccess({
+                data: sorted,
+                meta: { count: sorted.length },
+            });
         }
     }));
     projects

package/dist/commands/read-shortcut.d.ts

@@ -9,4 +9,4 @@ export declare function setupReadShortcut(program: Command): void;
  * `issues read` (in `commands/issues.ts`) both call one implementation
  * instead of carrying byte-equivalent duplicates. ALL-938 cleanup.
  */
-export declare function readIssues(issueIds: string[], _options: Record<string, unknown>, command: Command): Promise<void>;
+export declare function readIssues(issueIds: string[], options: Record<string, unknown>, command: Command): Promise<void>;

package/dist/commands/read-shortcut.js

@@ -1,8 +1,7 @@
 import { downloadLinearUploads } from "../utils/download-uploads.js";
+import { extractField } from "../utils/extract-field.js";
 import { createFileService } from "../utils/file-service.js";
-import { GraphQLIssuesService } from "../utils/graphql-issues-service.js";
-import { createGraphQLService } from "../utils/graphql-service.js";
-import { createLinearService } from "../utils/linear-service.js";
+import { createIssuesService } from "../utils/issues-service-bootstrap.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 /**
@@ -21,7 +20,10 @@ export function setupReadShortcut(program) {
         .alias("view")
         .alias("show")
         .description("Shortcut for `issues read`. Get issue details by identifier.")
-        .addHelpText("after", "\nExamples:\n  el-linear read ADM-652\n  el-linear get DEV-123 DEV-456\n  el-linear ADM-652          (auto-detected)")
+        .option("--field <name>", 'Extract a single named section from the issue description (e.g. "Done when"). ' +
+        "Matches H2/H3 headers and bold pseudo-headers case-insensitively. " +
+        "Outputs the section text only — no JSON envelope.")
+        .addHelpText("after", '\nExamples:\n  el-linear read ADM-652\n  el-linear get DEV-123 DEV-456\n  el-linear ADM-652          (auto-detected)\n  el-linear read DEV-123 --field "Done when"   (just that section)')
         .action(handleAsyncCommand(readIssues));
     // Catch-all: if argv looks like `el-linear ADM-652 [DEV-123 ...]`, run read
     const originalParse = program.parse.bind(program);
@@ -54,15 +56,33 @@ export function setupReadShortcut(program) {
  * `issues read` (in `commands/issues.ts`) both call one implementation
  * instead of carrying byte-equivalent duplicates. ALL-938 cleanup.
  */
-export async function readIssues(issueIds, _options, command) {
+export async function readIssues(issueIds, options, command) {
     const rootOpts = getRootOpts(command);
-    const graphQLService = await createGraphQLService(rootOpts);
-    const linearService = await createLinearService(rootOpts);
-    const issuesService = new GraphQLIssuesService(graphQLService, linearService);
+    const { issuesService } = await createIssuesService(rootOpts);
     const fileService = await createFileService(rootOpts);
+    const fieldName = typeof options.field === "string" ? options.field : null;
+    // --field is single-issue only. With multiple issues, a section
+    // extraction can't sensibly fan out to N different bodies — the
+    // caller almost always wants one section from one issue.
+    if (fieldName && issueIds.length > 1) {
+        throw new Error("--field is single-issue only; pass exactly one issueId. " +
+            "For multiple issues, drop --field and use --jq or --format summary.");
+    }
     if (issueIds.length === 1) {
         const issue = await issuesService.getIssueById(issueIds[0]);
         const resolved = await downloadLinearUploads(issue, fileService);
+        if (fieldName) {
+            const section = extractField(resolved.description ?? "", fieldName);
+            if (section === null) {
+                // Print nothing to stdout, exit non-zero with a stderr hint.
+                // Mirrors `grep` semantics for "not found" — scripts can
+                // branch on the exit code.
+                process.stderr.write(`el-linear: section "${fieldName}" not found in ${resolved.identifier}'s description\n`);
+                process.exit(1);
+            }
+            process.stdout.write(`${section}\n`);
+            return;
+        }
         outputSuccess(resolved);
     }
     else {

package/dist/commands/refs.js

@@ -1,4 +1,4 @@
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync, statSync } from "node:fs";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { extractIssueReferences } from "../utils/issue-reference-extractor.js";
 import { wrapIssueReferencesAsLinks, } from "../utils/issue-reference-wrapper.js";
@@ -50,16 +50,70 @@ export async function wrapRefsCore(input, deps) {
     const urlKey = await deps.resolveUrlKey();
     return wrapIssueReferencesAsLinks(input.text, validIds, urlKey, input.target);
 }
-async function handleWrap(options, command) {
+/**
+ * Return `path` if it resolves to an existing regular file on disk, else
+ * `null`. Used by `handleWrap` to disambiguate the `el-linear refs wrap <arg>`
+ * shape between "wrap this literal text" and "wrap the contents of this file".
+ *
+ * Concerns intentionally NOT addressed:
+ *   - Symlinks → resolved transparently by `statSync` (followSymlinks=true).
+ *   - Directories → returned as null (statSync().isFile() is false).
+ *   - Permission-denied / EACCES → returned as null; the caller falls back to
+ *     treating the arg as text. The eventual `readFileSync` would surface the
+ *     real error if the user did mean a file.
+ *
+ * Reference: DEV-4077 (vertical-int/tools MR !516 / !517 incident reports).
+ */
+function pathIfExistingFile(candidate) {
+    if (!candidate || candidate.includes("\n"))
+        return null;
+    try {
+        if (existsSync(candidate) && statSync(candidate).isFile()) {
+            return candidate;
+        }
+    }
+    catch {
+        // EACCES / EPERM / ELOOP → treat as not-a-file; downstream text path
+        // either passes through harmlessly or raises a more useful error.
+    }
+    return null;
+}
+async function handleWrap(textArgs, options, command) {
     const target = options.target ?? "markdown";
     if (!isWrapTarget(target)) {
         throw new Error(`Invalid --target "${target}". Expected one of: ${[...VALID_TARGETS].join(", ")}`);
     }
     // `validate` is `true` by default and `false` when `--no-validate` is passed.
     const validate = options.validate !== false;
-    const text = typeof options.file === "string" && options.file.length > 0
-        ? readFileSync(options.file, "utf8")
-        : await readAllStdin();
+    // Input precedence: positional args > --file > stdin. A single positional
+    // arg that resolves to an existing file is treated as a file path (the
+    // natural `el-linear refs wrap body.md` shape that users hit blind);
+    // otherwise positional args are joined as text. This auto-detect closes
+    // DEV-4077: the published v1.8.1 rejected `wrap <file>` outright, and the
+    // v1.10.0 source treated it as literal text — producing silently wrong
+    // output instead of an error. With this change, either form works.
+    let text;
+    if (textArgs.length === 1) {
+        const positionalFile = pathIfExistingFile(textArgs[0]);
+        if (positionalFile !== null) {
+            if (typeof options.file === "string" && options.file.length > 0) {
+                throw new Error(`Both a positional file path (${positionalFile}) and --file ${options.file} were provided. Use one or the other.`);
+            }
+            text = readFileSync(positionalFile, "utf8");
+        }
+        else {
+            text = textArgs[0];
+        }
+    }
+    else if (textArgs.length > 1) {
+        text = textArgs.join(" ");
+    }
+    else if (typeof options.file === "string" && options.file.length > 0) {
+        text = readFileSync(options.file, "utf8");
+    }
+    else {
+        text = await readAllStdin();
+    }
     const rootOpts = getRootOpts(command);
     const deps = {
         async resolveValidIdentifiers(ids) {
@@ -94,9 +148,14 @@ export function setupRefsCommands(program) {
     refs
         .command("wrap")
         .description("Wrap recognized Linear issue identifiers in input text as links. " +
-        "Reads from stdin (or --file) and writes to stdout. By default, " +
-        "each candidate identifier is validated against the workspace; " +
-        "unresolvable ones are left as plain text.")
+        "Input precedence: positional args > --file > stdin. A single positional " +
+        "arg that resolves to an existing file is read as a file (so " +
+        "`el-linear refs wrap body.md` works the same as `--file body.md`); " +
+        "otherwise positional args are joined as literal text. " +
+        "Writes the result to stdout. By default, each candidate identifier " +
+        "is validated against the workspace; unresolvable ones are left as " +
+        "plain text.")
+        .argument("[text...]", "input text OR a path to a file. A single positional arg that exists as a file is read; otherwise positional args are joined as literal text with a single space.")
         .option("--file <path>", "read input from a file instead of stdin")
         .option("--target <target>", "output format: markdown (default) or slack", "markdown")
         .option("--no-validate", "skip workspace validation; wrap every regex match. Faster, but may produce broken links for IDs that don't exist.")

package/dist/commands/search.js

@@ -23,11 +23,28 @@ const VALID_TYPES = new Set([
     "document",
     "template",
 ]);
+/**
+ * `SemanticSearchResult`-valid types only (drops "template" — templates
+ * come from a separate query, not `semanticSearch`). Used to filter
+ * unknown types out of the response BEFORE they reach
+ * `transformSearchResult` — the transformer's switch has a
+ * `satisfies never` exhaustiveness guard that would otherwise return
+ * the raw row on a never-typed default branch.
+ */
+const SEMANTIC_TYPES = new Set([
+    "issue",
+    "project",
+    "initiative",
+    "document",
+]);
+function isKnownSemanticResult(r) {
+    return SEMANTIC_TYPES.has(r.type);
+}
 const WHITESPACE_RE = /\s+/;
 function transformSearchResult(r) {
     switch (r.type) {
         case "issue": {
-            const issue = r.issue;
+            const { issue } = r;
             return {
                 type: "issue",
                 identifier: issue?.identifier,
@@ -68,7 +85,10 @@ function transformSearchResult(r) {
             };
         }
         default:
-            return { type: r.type, id: null };
+            // Exhaustiveness check: SemanticSearchResult is a closed union, so
+            // `r` is `never` here — adding a new arm to the union forces a new
+            // case branch (the compiler error makes it impossible to forget).
+            return r;
     }
 }
 function matchesQuery(name, query) {
@@ -114,10 +134,15 @@ function buildSemanticQuery(graphQLService, query, limit, teamOption) {
     });
 }
 function extractSemanticResults(semanticResult, requestedTypes, onlyTemplates) {
-    let results = semanticResult.semanticSearch?.results ?? [];
+    // Always drop rows with unknown `type` first — defends the transformer
+    // against future Linear API expansions adding a new variant before
+    // SemanticSearchResult's union is widened. Without this, an unknown
+    // type would reach the transformer's `satisfies never` default and
+    // pass through as a raw row.
+    let results = (semanticResult.semanticSearch?.results ?? []).filter(isKnownSemanticResult);
     if (requestedTypes && !onlyTemplates) {
-        const semanticTypes = requestedTypes.filter((t) => t !== "template");
-        results = results.filter((r) => semanticTypes.includes(r.type));
+        const semanticTypes = new Set(requestedTypes.filter((t) => t !== "template"));
+        results = results.filter((r) => semanticTypes.has(r.type));
     }
     return results.map(transformSearchResult);
 }

package/dist/commands/users.js

@@ -1,5 +1,5 @@
 import { createLinearService } from "../utils/linear-service.js";
-import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
+import { handleAsyncCommand, outputSuccess, warnIfTruncated, } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
 import { parsePositiveInt } from "../utils/validators.js";
 export function setupUsersCommands(program) {
@@ -14,7 +14,9 @@ export function setupUsersCommands(program) {
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
         const service = await createLinearService(rootOpts);
-        const result = await service.getUsers(options.active, parsePositiveInt(options.limit, "--limit"), options.name);
+        const limit = parsePositiveInt(options.limit, "--limit");
+        const result = await service.getUsers(options.active, limit, options.name);
+        warnIfTruncated(result.length, limit);
         outputSuccess({ data: result, meta: { count: result.length } });
     }));
 }

package/dist/config/config.d.ts

@@ -1,4 +1,15 @@
 import type { TermRule } from "./term-enforcer.js";
+/**
+ * Source attribution for the active team-config layer. Surfaced via
+ * `getActiveTeamConfigInfo()` and rendered by `el-linear config team show` so
+ * the operator can debug "which file is el-linear actually loading?".
+ *
+ * - `env`: `EL_LINEAR_TEAM_CONFIG` is set in the environment (highest).
+ * - `personal`: `teamConfigPath` field in personal `config.json`.
+ * - `marker`: auto-discovered via `~/.config/el-tools-root` (DEV-4258).
+ * - `null`: no team layer active.
+ */
+export type TeamConfigSource = "env" | "personal" | "marker" | null;
 /**
  * Canonical shape of `~/.config/el-linear/config.json`. This is the single source
  * of truth for the on-disk config — the wizard reads/writes the same shape
@@ -27,6 +38,10 @@ export interface ElLinearConfig {
      * Term-enforcement rules. Each rule has a canonical form and a list of
      * rejected forms; rejected forms in issue titles/descriptions are flagged
      * (or thrown on, in strict mode) with a hint to use the canonical form.
+     *
+     * When a team config layer is active, personal `terms` are appended to the
+     * team's rules (not replaced). To start fresh, omit `terms` from personal
+     * config entirely.
      */
     terms: TermRule[];
     validation?: {
@@ -61,12 +76,17 @@ export interface ElLinearConfig {
      * Default assignee identifier (alias / display name / email / UUID — same
      * shapes resolveAssignee accepts) for `issues create`. Applied when
      * `--assignee` is not passed. Pass `--no-assignee` to override at one site.
+     *
+     * Prefer setting this in `local.json` instead of `config.json` so it stays
+     * out of shared team config.
      */
     defaultAssignee?: string;
     /**
      * Default priority for `issues create` / `issues update`. Accepts the same
      * keywords as the --priority flag: `none|urgent|high|medium|normal|low`
      * or `0`–`4`. Applied when `--priority` is not passed.
+     *
+     * Prefer setting this in `local.json` instead of `config.json`.
      */
     defaultPriority?: string;
     /**
@@ -74,9 +94,87 @@ export interface ElLinearConfig {
      * and `projects list`. Defaults to 3600 (1 hour) when omitted. A value of
      * `0` disables the cache entirely. Override per-invocation with
      * `--no-cache`.
+     *
+     * Prefer setting this in `local.json` instead of `config.json`.
      */
     cacheTTLSeconds?: number;
+    /**
+     * Path to a shared team config file. Fields in the team config are merged
+     * under the personal config (personal config wins on conflicts). Arrays such
+     * as `terms` and `defaultLabels` are concatenated — personal entries are
+     * appended to team entries. The team config accepts any ElLinearConfig fields
+     * except `teamConfigPath` itself. Useful for sharing member aliases, label
+     * maps, and term rules across a team by checking the file into a shared
+     * repository. Override at runtime with the `EL_LINEAR_TEAM_CONFIG` env var
+     * (env var takes precedence over this field).
+     */
+    teamConfigPath?: string;
 }
-/** Test seam — resets the cache between test cases. */
+/**
+ * Fields valid in a shared team config file (the file pointed to by
+ * `teamConfigPath` or `EL_LINEAR_TEAM_CONFIG`). All fields are optional —
+ * omitted fields fall back to defaults or the personal config layer. The type
+ * excludes `teamConfigPath` itself to prevent circular references.
+ */
+export type TeamConfig = Omit<ElLinearConfig, "teamConfigPath">;
+/**
+ * User-local overrides that live in `~/.config/el-linear/local.json` (or the
+ * per-profile equivalent). These are applied on top of the merged team+personal
+ * config, so every field here takes the highest precedence.
+ *
+ * Use `local.json` for anything that is personal rather than team-wide:
+ * your own email, personal default priority, cache preferences. Never commit
+ * `local.json` to a shared repo — it is `.gitignore`-worthy by nature.
+ *
+ * Merge order (lowest → highest priority):
+ *   defaults → team config file → personal config.json → local.json
+ */
+export interface ElLinearLocalConfig {
+    /**
+     * Your Linear account email. Used as the default `--assignee` when creating
+     * issues. Takes precedence over `config.json`'s `defaultAssignee`.
+     *
+     * Example: "ytspar@gmail.com"
+     */
+    assigneeEmail?: string;
+    /** Same semantics as `ElLinearConfig.defaultAssignee`, but local-wins. */
+    defaultAssignee?: string;
+    /** Same semantics as `ElLinearConfig.defaultPriority`, but local-wins. */
+    defaultPriority?: string;
+    /** Same semantics as `ElLinearConfig.cacheTTLSeconds`, but local-wins. */
+    cacheTTLSeconds?: number;
+}
+/** Test seam — resets all caches between test cases. */
 export declare function _resetConfigCacheForTests(): void;
 export declare function loadConfig(): ElLinearConfig;
+/**
+ * Returns the team config file path that is active for the current process
+ * (resolved via `EL_LINEAR_TEAM_CONFIG` env var, `teamConfigPath` in personal
+ * config, or `~/.config/el-tools-root` marker — in that order). Returns
+ * `undefined` when no team config is configured.
+ *
+ * Calling this before `loadConfig()` will trigger a `loadConfig()` internally
+ * so the path cache is populated.
+ */
+export declare function getActiveTeamConfigPath(): string | undefined;
+/**
+ * Returns the active team-config path AND the source it was resolved from
+ * (env var / personal config field / onboarding-marker auto-discovery).
+ * `el-linear config team show` uses this to render which resolver fired —
+ * so an operator debugging "why isn't my team config loading?" sees the
+ * answer in one command.
+ *
+ * Re-derives source on each call rather than caching it: the lookup is cheap
+ * (one file read at most for personal config, one for the marker) and only
+ * `config team show` calls it.
+ */
+export declare function getActiveTeamConfigInfo(): {
+    path: string | undefined;
+    source: TeamConfigSource;
+};
+/**
+ * Load user-local overrides from `local.json`. Returns an empty object when
+ * no file exists — callers treat it as "no overrides". Errors are silent so
+ * a missing or malformed `local.json` never breaks a command.
+ */
+export declare function loadLocalConfig(): ElLinearLocalConfig;