@enrichlayer/el-linear 1.9.0 → 1.15.0

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) {
@@ -68,6 +122,13 @@ async function handleWrap(options, command) {
             return new Set(map.keys());
         },
         async resolveUrlKey() {
+            // When --workspace-url-key or EL_LINEAR_WORKSPACE_URL_KEY supplies
+            // the key, the live lookup never fires — skip the GraphQL service
+            // instantiation entirely so `refs wrap --no-validate` works offline.
+            const override = options.workspaceUrlKey;
+            if (override || process.env.EL_LINEAR_WORKSPACE_URL_KEY) {
+                return getWorkspaceUrlKey(undefined, { override });
+            }
             const graphQLService = await createGraphQLService(rootOpts);
             return getWorkspaceUrlKey(graphQLService);
         },
@@ -87,11 +148,17 @@ 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.")
+        .option("--workspace-url-key <key>", "workspace URL key (the segment after linear.app/). Overrides config + env var. With --no-validate, makes the command fully offline.")
         .action(handleAsyncCommand(handleWrap));
 }

package/dist/commands/releases.js

@@ -2,18 +2,24 @@ import { CREATE_RELEASE_MUTATION, GET_RELEASE_BY_ID_QUERY, GET_RELEASE_PIPELINES
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
 function transformRelease(release) {
+    // Lifecycle timestamps + dates only exist on the list/detail node shapes,
+    // not on the create-mutation shape; read defensively rather than splitting
+    // the function in two.
+    const r = release;
+    const documents = release.documents?.nodes;
     return {
         id: release.id,
         name: release.name,
-        description: release.description || undefined,
-        version: release.version || undefined,
-        url: release.url || undefined,
-        startDate: release.startDate || undefined,
-        targetDate: release.targetDate || undefined,
-        startedAt: release.startedAt || undefined,
-        completedAt: release.completedAt || undefined,
-        canceledAt: release.canceledAt || undefined,
+        description: release.description ?? undefined,
+        version: release.version ?? undefined,
+        url: release.url ?? undefined,
+        startDate: r.startDate ?? undefined,
+        targetDate: r.targetDate ?? undefined,
+        startedAt: r.startedAt ?? undefined,
+        completedAt: r.completedAt ?? undefined,
+        canceledAt: r.canceledAt ?? undefined,
         stage: release.stage
             ? {
                 id: release.stage.id,
@@ -27,7 +33,7 @@ function transformRelease(release) {
                 name: release.pipeline.name,
             }
             : undefined,
-        documents: release.documents?.nodes?.map((d) => ({
+        documents: documents?.map((d) => ({
             id: d.id,
             title: d.title,
             slugId: d.slugId,
@@ -40,14 +46,11 @@ async function handleCreateRelease(name, options, command) {
     const rootOpts = getRootOpts(command);
     const graphQLService = await createGraphQLService(rootOpts);
     const pipelines = await graphQLService.rawRequest(GET_RELEASE_PIPELINES_QUERY, { first: 50 });
-    const pipelineNodes = pipelines.releasePipelines
-        ?.nodes;
-    const pipeline = pipelineNodes?.find((p) => p.id === options.pipeline ||
+    const pipelineNodes = pipelines.releasePipelines.nodes;
+    const pipeline = pipelineNodes.find((p) => p.id === options.pipeline ||
         p.name.toLowerCase() === options.pipeline.toLowerCase());
     if (!pipeline) {
-        const available = (pipelineNodes ?? [])
-            .map((p) => p.name)
-            .join(", ");
+        const available = pipelineNodes.map((p) => p.name).join(", ");
         throw new Error(`Pipeline "${options.pipeline}" not found. Available: ${available || "none"}`);
     }
     const input = { name, pipelineId: pipeline.id };
@@ -58,21 +61,17 @@ async function handleCreateRelease(name, options, command) {
         input.version = options.version;
     }
     if (options.stage) {
-        const stageNodes = pipeline.stages?.nodes;
-        const stage = stageNodes?.find((s) => s.id === options.stage ||
+        const stage = pipeline.stages.nodes.find((s) => s.id === options.stage ||
             s.name.toLowerCase() === options.stage.toLowerCase());
         if (stage) {
             input.stageId = stage.id;
         }
     }
-    const result = await graphQLService.rawRequest(CREATE_RELEASE_MUTATION, {
-        input,
-    });
-    const releaseCreate = result.releaseCreate;
-    if (!releaseCreate?.success) {
+    const result = await graphQLService.rawRequest(CREATE_RELEASE_MUTATION, { input });
+    if (!result.releaseCreate.success || !result.releaseCreate.release) {
         throw new Error(`Failed to create release "${name}"`);
     }
-    outputSuccess(transformRelease(releaseCreate.release));
+    outputSuccess(transformRelease(result.releaseCreate.release));
 }
 export function setupReleasesCommands(program) {
     const releases = program
@@ -92,11 +91,10 @@ export function setupReleasesCommands(program) {
             filter.pipeline = { name: { eqIgnoreCase: options.pipeline } };
         }
         const result = await graphQLService.rawRequest(GET_RELEASES_QUERY, {
-            first: Number.parseInt(options.limit, 10),
+            first: parsePositiveInt(options.limit, "--limit"),
             filter: Object.keys(filter).length > 0 ? filter : undefined,
         });
-        const data = (result.releases
-            ?.nodes ?? []).map(transformRelease);
+        const data = result.releases.nodes.map(transformRelease);
         outputSuccess({ data, meta: { count: data.length } });
     }));
     releases
@@ -126,12 +124,10 @@ export function setupReleasesCommands(program) {
         const rootOpts = getRootOpts(command);
         const graphQLService = await createGraphQLService(rootOpts);
         const result = await graphQLService.rawRequest(GET_RELEASE_PIPELINES_QUERY, { first: 50 });
-        const data = (result.releasePipelines
-            ?.nodes ?? []).map((p) => ({
+        const data = result.releasePipelines.nodes.map((p) => ({
             id: p.id,
             name: p.name,
-            stages: (p.stages
-                ?.nodes ?? []).map((s) => ({
+            stages: p.stages.nodes.map((s) => ({
                 id: s.id,
                 name: s.name,
                 type: s.type,

package/dist/commands/search.js

@@ -3,6 +3,7 @@ import { SEMANTIC_SEARCH_QUERY } from "../queries/search.js";
 import { createGraphQLService } from "../utils/graphql-service.js";
 import { handleAsyncCommand, outputSuccess } from "../utils/output.js";
 import { getRootOpts } from "../utils/root-opts.js";
+import { parsePositiveInt } from "../utils/validators.js";
 const TEMPLATES_QUERY = `
   query {
     templates {
@@ -22,61 +23,72 @@ 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) {
-    const rType = r.type;
-    switch (rType) {
+    switch (r.type) {
         case "issue": {
-            const issue = r.issue;
-            const state = issue?.state;
-            const team = issue?.team;
-            const assignee = issue?.assignee;
-            const project = issue?.project;
+            const { issue } = r;
             return {
                 type: "issue",
                 identifier: issue?.identifier,
                 title: issue?.title,
-                state: state?.name,
-                team: team?.key,
-                assignee: assignee
-                    ? resolveUserDisplayName(assignee.id, assignee.name)
+                state: issue?.state?.name,
+                team: issue?.team?.key,
+                assignee: issue?.assignee
+                    ? resolveUserDisplayName(issue.assignee.id, issue.assignee.name)
                     : undefined,
-                priority: issue?.priority,
-                project: project?.name,
+                priority: issue?.priority ?? undefined,
+                project: issue?.project?.name,
                 id: issue?.id,
             };
         }
         case "project": {
-            const project = r.project;
             return {
                 type: "project",
-                name: project?.name,
-                state: project?.state,
-                id: project?.id,
+                name: r.project?.name,
+                state: r.project?.state,
+                id: r.project?.id,
             };
         }
         case "initiative": {
-            const initiative = r.initiative;
             return {
                 type: "initiative",
-                name: initiative?.name,
-                status: initiative?.status,
-                id: initiative?.id,
+                name: r.initiative?.name,
+                status: r.initiative?.status ?? undefined,
+                id: r.initiative?.id,
             };
         }
         case "document": {
-            const doc = r.document;
-            const docProject = doc?.project;
             return {
                 type: "document",
-                title: doc?.title,
-                project: docProject?.name,
-                slugId: doc?.slugId,
-                id: doc?.id,
+                title: r.document?.title,
+                project: r.document?.project?.name,
+                slugId: r.document?.slugId ?? undefined,
+                id: r.document?.id,
             };
         }
         default:
-            return { type: rType, 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) {
@@ -122,11 +134,15 @@ function buildSemanticQuery(graphQLService, query, limit, teamOption) {
     });
 }
 function extractSemanticResults(semanticResult, requestedTypes, onlyTemplates) {
-    const semanticSearch = semanticResult.semanticSearch;
-    let results = 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);
 }
@@ -140,7 +156,7 @@ export function setupSearchCommands(program) {
         .action(handleAsyncCommand(async (query, options, command) => {
         const rootOpts = getRootOpts(command);
         const graphQLService = await createGraphQLService(rootOpts);
-        const limit = Number.parseInt(options.limit, 10);
+        const limit = parsePositiveInt(options.limit, "--limit");
         const requestedTypes = options.type
             ? options.type.split(",").map((t) => t.trim().toLowerCase())
             : null;

package/dist/commands/teams.js

@@ -3,6 +3,7 @@ import { cached, resolveCacheTTL } from "../utils/disk-cache.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";
 export function setupTeamsCommands(program) {
     const teams = program
         .command("teams")
@@ -15,7 +16,7 @@ export function setupTeamsCommands(program) {
         .option("-l, --limit <number>", "limit results", "100")
         .action(handleAsyncCommand(async (options, command) => {
         const rootOpts = getRootOpts(command);
-        const limit = Number.parseInt(options.limit, 10);
+        const limit = parsePositiveInt(options.limit, "--limit");
         const ttl = resolveCacheTTL({
             configTTL: loadConfig().cacheTTLSeconds,
             // commander's `--no-cache` produces `cache: false` on the root opts.

package/dist/commands/templates.js

@@ -48,14 +48,11 @@ export function setupTemplatesCommands(program) {
         .action(handleAsyncCommand(async (templateId, _options, command) => {
         const rootOpts = getRootOpts(command);
         const graphQLService = await createGraphQLService(rootOpts);
-        const result = await graphQLService.rawRequest(TEMPLATE_BY_ID_QUERY, {
-            id: templateId,
-        });
-        const template = result.template;
-        if (!template) {
+        const result = await graphQLService.rawRequest(TEMPLATE_BY_ID_QUERY, { id: templateId });
+        if (!result.template) {
             throw new Error(`Template "${templateId}" not found`);
         }
-        outputSuccess(template);
+        outputSuccess(result.template);
     }));
     templates
         .command("create")
@@ -87,11 +84,10 @@ export function setupTemplatesCommands(program) {
         if (options.color)
             input.color = options.color;
         const result = await graphQLService.rawRequest(TEMPLATE_CREATE_MUTATION, { input });
-        const payload = result.templateCreate;
-        if (!payload?.success) {
+        if (!result.templateCreate.success || !result.templateCreate.template) {
             throw new Error("templateCreate returned success=false");
         }
-        outputSuccess(payload.template);
+        outputSuccess(result.templateCreate.template);
     }));
     templates
         .command("update <templateId>")
@@ -126,11 +122,11 @@ export function setupTemplatesCommands(program) {
             throw new Error("templates update: at least one of --name, --description, --data, --data-file, --icon, --color, --team-id is required");
         }
         const result = await graphQLService.rawRequest(TEMPLATE_UPDATE_MUTATION, { id: templateId, input });
-        const payload = result.templateUpdate;
-        if (!payload?.success) {
+        if (!result.templateUpdate.success ||
+            !result.templateUpdate.template) {
             throw new Error("templateUpdate returned success=false");
         }
-        outputSuccess(payload.template);
+        outputSuccess(result.templateUpdate.template);
     }));
     templates
         .command("delete <templateId>")
@@ -139,8 +135,7 @@ export function setupTemplatesCommands(program) {
         const rootOpts = getRootOpts(command);
         const graphQLService = await createGraphQLService(rootOpts);
         const result = await graphQLService.rawRequest(TEMPLATE_DELETE_MUTATION, { id: templateId });
-        const payload = result.templateDelete;
-        if (!payload?.success) {
+        if (!result.templateDelete.success) {
             throw new Error("templateDelete returned success=false");
         }
         outputSuccess({ id: templateId, deleted: true });

package/dist/commands/users.js

@@ -1,6 +1,7 @@
 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) {
     const users = program.command("users").description("User operations");
     users.action(() => users.help());
@@ -13,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, Number.parseInt(options.limit, 10), 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;