linear-sdk-cli 0.3.3 → 0.5.0

package/src/commands/issue.ts

@@ -41,8 +41,9 @@ import { openUrl } from "../lib/open.js";
 import type { Context } from "../context.js";
 import * as svc from "../services/issue.js";
 import * as commentSvc from "../services/comment.js";
-import { isSelf, normalizeIssueReference, resolveIssue } from "../lib/resolve.js";
+import { isSelf, isUuid, normalizeIssueReference, resolveIssue } from "../lib/resolve.js";
 import type { Column } from "../output/table.js";
+import { lifecycleSuffix } from "../output/lifecycle.js";
 
 /** Resolve the target issue id from an argument/current branch, expanding `42` via the default team. */
 function requireId(idArg: string | undefined, defaultTeam?: string): string {
@@ -60,7 +61,7 @@ const ROW_COLUMNS: Column<svc.IssueRow>[] = [
   {
     key: "state",
     header: "State",
-    value: (r) => `${r.state?.name ?? ""}${lifecycleMark(r)}`,
+    value: (r) => `${r.state?.name ?? ""}${lifecycleSuffix(r)}`,
     max: 26,
   },
   { key: "priority", header: "Pri", value: (r) => shortPriority(r.priority) },
@@ -92,11 +93,6 @@ function shortPriority(p: number): string {
   return ["—", "Urgent", "High", "Med", "Low"][p] ?? String(p);
 }
 
-/** ` (trashed)` / ` (archived)` for a row that is not live; empty otherwise. */
-function lifecycleMark(r: Pick<svc.IssueRow, "trashed" | "archivedAt">): string {
-  return r.trashed ? " (trashed)" : r.archivedAt ? " (archived)" : "";
-}
-
 /** A removed reference flag whose meaning is already this CLI's query default. */
 function addNoopAllAssignees(command: Command): void {
   command.addOption(
@@ -362,6 +358,10 @@ export function registerIssue(program: Command): void {
     .option("--description-file <path>", "read description from a file ('-' = stdin)")
     .option("--editor", "compose the description in $EDITOR")
     .option("-a, --assignee <who>", "assignee (me|email|name|id)")
+    .option("--delegate <agent>", "delegate to an eligible agent app user (name or id)")
+    .option("--clear-delegate", "explicitly create with no agent delegate")
+    .option("--dry-run", "resolve and show the delegation mutation input without writing")
+    .option("--full-result", "read back and verify the resulting delegate")
     .option("-s, --state <name>", "workflow state name or type")
     .option("-P, --priority <0-4>", "priority", parsePriority)
     .option("-l, --label <name>", "label (repeatable / comma-separated)", parseList)
@@ -386,6 +386,8 @@ export function registerIssue(program: Command): void {
         "",
         "Examples:",
         "  linear issue create --title 'Fix login' --team TES --assignee me",
+        "  linear issue create --title 'Fix login' --assignee me --delegate Codex",
+        "  linear issue create --title 'Fix login' --delegate Codex --dry-run --json",
         "  linear issue create --title 'Bug' -l bug -l urgent --priority 1",
         "  linear issue create --title 'Sprint task' --cycle current --state 'In Progress'",
         "  linear issue create --title 'Sub-task' --parent TES-42          # inherits TES-42's project",
@@ -396,6 +398,13 @@ export function registerIssue(program: Command): void {
     )
     .action(
       action(async (ctx: Context, opts) => {
+        const delegationChanged = opts.delegate !== undefined || opts.clearDelegate === true;
+        const mode = delegationMutationMode(opts, delegationChanged);
+        if (opts.start && mode.dryRun) {
+          throw usageError(
+            "--dry-run cannot be combined with --start, which also changes git and state.",
+          );
+        }
         // `--start` means *you* are starting on it, so it assigns to you (as the
         // reference CLI does); naming somebody else at the same time is a contradiction.
         if (opts.start && opts.assignee && !isSelf(opts.assignee)) {
@@ -411,13 +420,15 @@ export function registerIssue(program: Command): void {
           interactive: !!opts.editor && ctx.isTTY,
           editorRequested: !!opts.editor,
         });
-        const created = await svc.createIssue(
+        const plan = await svc.prepareIssueCreate(
           ctx.client,
           {
             title,
             description,
             team: opts.team ?? ctx.defaultTeam,
             assignee: opts.start ? (opts.assignee ?? "me") : opts.assignee,
+            delegate: opts.delegate,
+            clearDelegate: opts.clearDelegate,
             state: opts.state,
             priority: opts.priority,
             label: opts.label,
@@ -433,7 +444,16 @@ export function registerIssue(program: Command): void {
           },
           ctx.defaultTeam,
         );
+        if (mode.dryRun) {
+          emitMutationPreview(ctx, plan);
+          return;
+        }
+        const created = await svc.executeIssueCreate(ctx.client, plan);
         if (!opts.start) {
+          if (delegationChanged) {
+            await emitDelegationResult(ctx, created, plan, mode.fullResult, "Created");
+            return;
+          }
           ctx.output.emit(
             { id: created.id, identifier: created.identifier, url: created.url },
             () => ctx.output.success(`Created ${created.identifier}: ${created.url}`),
@@ -448,6 +468,16 @@ export function registerIssue(program: Command): void {
         // (dirty tree, invalid ref, …), the issue remains in its existing state.
         const branchResult = isGitRepo() ? checkoutBranch(created.branchName) : undefined;
         await svc.moveIssueState(ctx.client, created, { move: moved });
+        if (delegationChanged) {
+          await emitDelegationResult(ctx, created, plan, mode.fullResult, "Created");
+          if (branchResult)
+            ctx.output.success(
+              `${branchResult.created ? "Created and checked out" : "Checked out"} ${branchResult.branch}`,
+            );
+          else ctx.output.info(`Branch name: ${created.branchName}`);
+          if (moved) ctx.output.success(`Moved ${created.identifier} → started`);
+          return;
+        }
         ctx.output.emit(
           {
             id: created.id,
@@ -471,6 +501,7 @@ export function registerIssue(program: Command): void {
     );
   addAliasOption(create, "--due-date <date>", "--due");
   addAliasOption(create, "--no-use-default-template", "--no-default-template");
+  addAliasOption(create, "--read-back", "--full-result");
 
   // update ------------------------------------------------------------------
   const update = issue
@@ -485,6 +516,7 @@ export function registerIssue(program: Command): void {
     // lookup. (addGlobalOptions leaves a locally-declared global alone.)
     .option("-t, --team <key>", "move the issue to another team (changes its identifier)")
     .option("-a, --assignee <who>", "assignee (me|email|name|id)")
+    .option("--delegate <agent>", "delegate to an eligible agent app user (name or id)")
     .option("-s, --state <name>", "workflow state name or type")
     .option("-P, --priority <0-4>", "priority", parsePriority)
     .option("-p, --project <name>", "project name or id")
@@ -497,13 +529,18 @@ export function registerIssue(program: Command): void {
     .option("--add-label <name>", "add a label (repeatable)", parseList)
     .option("--remove-label <name>", "remove a label (repeatable)", parseList)
     .option("--unassign", "clear the assignee")
+    .option("--clear-delegate", "remove the agent delegate")
     .option("--clear-cycle", "remove the issue from its cycle")
+    .option("--dry-run", "resolve and show the delegation mutation input without writing")
+    .option("--full-result", "read back and verify the resulting delegate")
     .addHelpText(
       "after",
       [
         "",
         "Examples:",
         "  linear issue update TES-42 --state 'In Progress' --assignee me",
+        "  linear issue update TES-42 --delegate Codex",
+        "  linear issue update TES-42 --clear-delegate",
         "  linear issue update --priority 1 --add-label regression   # id from branch",
         "  linear issue update TES-42 --cycle current --json",
         "  linear issue update TES-42 --team ENG   # move to another team (new identifier)",
@@ -511,18 +548,21 @@ export function registerIssue(program: Command): void {
     )
     .action(
       action(async (ctx: Context, opts, idArg?: string) => {
+        const delegationChanged = opts.delegate !== undefined || opts.clearDelegate === true;
+        const mode = delegationMutationMode(opts, delegationChanged);
         const description = resolveBody({
           arg: opts.description,
           file: opts.descriptionFile,
           interactive: false,
         });
-        const updated = await svc.updateIssue(ctx.client, requireId(idArg, ctx.defaultTeam), {
+        const plan = await svc.prepareIssueUpdate(ctx.client, requireId(idArg, ctx.defaultTeam), {
           title: opts.title,
           description,
           // Only the explicit flag moves an issue — never `ctx.defaultTeam`, or
           // every update in a repo with a configured team would be a team move.
           team: opts.team,
           assignee: opts.assignee,
+          delegate: opts.delegate,
           state: opts.state,
           priority: opts.priority,
           project: opts.project,
@@ -535,8 +575,18 @@ export function registerIssue(program: Command): void {
           addLabel: opts.addLabel,
           removeLabel: opts.removeLabel,
           unassign: opts.unassign,
+          clearDelegate: opts.clearDelegate,
           clearCycle: opts.clearCycle,
         });
+        if (mode.dryRun) {
+          emitMutationPreview(ctx, plan);
+          return;
+        }
+        const updated = await svc.executeIssueUpdate(ctx.client, plan);
+        if (delegationChanged) {
+          await emitDelegationResult(ctx, updated, plan, mode.fullResult, "Updated");
+          return;
+        }
         ctx.output.emit(
           { id: updated.id, identifier: updated.identifier, url: updated.url },
           () => {
@@ -555,6 +605,7 @@ export function registerIssue(program: Command): void {
       }),
     );
   addAliasOption(update, "--due-date <date>", "--due");
+  addAliasOption(update, "--read-back", "--full-result");
 
   // assign / state ----------------------------------------------------------
   issue
@@ -572,6 +623,61 @@ export function registerIssue(program: Command): void {
       }),
     );
 
+  const delegate = issue
+    .command("delegate [idOrAgent] [agent]")
+    .description(
+      "Delegate an issue to an eligible agent, or --clear it. Issue defaults to the branch.",
+    )
+    .option("--clear", "remove the agent delegate")
+    .option("--dry-run", "resolve and show the exact delegateId without writing")
+    .option("--full-result", "read back the full issue and verify the resulting delegate")
+    .addHelpText(
+      "after",
+      [
+        "",
+        "Examples:",
+        "  linear issue delegate TES-42 Codex",
+        "  linear issue delegate Codex              # issue from branch",
+        "  linear issue delegate <agent-user-uuid>  # issue from branch",
+        "  linear issue delegate TES-42 --clear",
+        "  linear issue delegate --clear             # issue from branch",
+        "",
+        "Delegating may trigger an Agent Session/webhook. Clearing the delegate does not",
+        "claim to cancel a session that is already running.",
+      ].join("\n"),
+    )
+    .action(
+      action(async (ctx: Context, opts, a?: string, b?: string) => {
+        const mode = delegationMutationMode(opts, true);
+        let idArg: string | undefined;
+        let change: svc.UpdateOptions;
+        if (opts.clear) {
+          if (b !== undefined || (a !== undefined && !ISSUE_ID_RE.test(a))) {
+            throw usageError("Pass either an agent or --clear, not both.");
+          }
+          idArg = a;
+          change = { clearDelegate: true };
+        } else {
+          const parsed = delegateOperands(a, b);
+          idArg = parsed.idArg;
+          change = { delegate: parsed.value };
+        }
+        const plan = await svc.prepareIssueUpdate(
+          ctx.client,
+          requireId(idArg, ctx.defaultTeam),
+          change,
+          "issue.delegate",
+        );
+        if (mode.dryRun) {
+          emitMutationPreview(ctx, plan);
+          return;
+        }
+        const updated = await svc.executeIssueUpdate(ctx.client, plan);
+        await emitDelegationResult(ctx, updated, plan, mode.fullResult, "Delegated");
+      }),
+    );
+  addAliasOption(delegate, "--read-back", "--full-result");
+
   issue
     .command("state [idOrState] [state]")
     .description("Move an issue to a workflow state. Issue defaults to the branch.")
@@ -588,14 +694,111 @@ export function registerIssue(program: Command): void {
     );
 
   // label -------------------------------------------------------------------
-  issue
+  const labelCommand = issue
     .command("label [id]")
-    .description("Add/remove labels on an issue")
+    .description("Add, remove, or replace one member of a label group on an issue")
     .option("--add <name>", "add a label (repeatable)", parseList)
     .option("--remove <name>", "remove a label (repeatable)", parseList)
+    .option(
+      "--set-group <group=label>",
+      "replace a group's direct member (repeatable; exact name or UUID)",
+      collectArray,
+    )
+    .option("--dry-run", "resolve and show the exact relative-label mutation without writing")
+    .option("--full-result", "read back and verify the resulting group labels")
+    .addHelpText(
+      "after",
+      [
+        "",
+        "Examples:",
+        "  linear issue label TES-42 --add regression",
+        "  linear issue label TES-42 --set-group 'Team=QA'",
+        "  linear issue label TES-42 --set-group 'Team=QA' --set-group 'Issue Type=Bug' --json",
+        "",
+        "--set-group splits on the first '='. Quote the whole value when either name has spaces",
+        "or shell metacharacters. '=' needs no escaping in the label name; use the group UUID",
+        "when the group name itself contains '='. Group and label names match exactly.",
+        "",
+        "Concurrency: the command reads current labels, then sends one addedLabelIds/removedLabelIds",
+        "update. Unrelated concurrent label changes are preserved, but another change to the same",
+        "group can race between that read and update; --full-result verifies the state afterward.",
+      ].join("\n"),
+    )
     .action(
       action(async (ctx: Context, opts, idArg?: string) => {
-        if (!opts.add && !opts.remove) throw usageError("Pass --add and/or --remove.");
+        const setGroup: string[] | undefined = opts.setGroup;
+        const dryRun = opts.dryRun === true;
+        const fullResult = readAlias<boolean>(opts, "--full-result", "--read-back") === true;
+        if (dryRun && fullResult) {
+          throw usageError("Pass either --dry-run or --full-result, not both.");
+        }
+        if (setGroup?.length) {
+          if (opts.add || opts.remove) {
+            throw usageError("Pass either --set-group or --add/--remove, not both.");
+          }
+          const plan = await svc.prepareIssueLabelGroupUpdate(
+            ctx.client,
+            requireId(idArg, ctx.defaultTeam),
+            setGroup,
+          );
+          if (dryRun) {
+            emitIssueLabelGroupPreview(ctx, plan);
+            return;
+          }
+          const mutationSent = await svc.executeIssueLabelGroupUpdate(ctx.client, plan);
+          const receipt = svc.issueLabelGroupReceipt(plan, mutationSent);
+          if (fullResult) {
+            let detail: svc.IssueDetail;
+            let actualLabels: svc.IssueLabelRef[];
+            try {
+              detail = await svc.getIssueDetail(ctx.client, plan.target.id, {
+                includeComments: false,
+              });
+              actualLabels = await svc.getIssueLabelRefs(ctx.client, plan.target.id);
+            } catch (err) {
+              const normalized = normalizeError(err);
+              throw new CliError(
+                mutationSent
+                  ? `Issue mutation succeeded, but label-group read-back failed: ${normalized.message}. The write may have committed.`
+                  : `Label-group read-back failed after the no-op: ${normalized.message}. No mutation was sent.`,
+                normalized.code,
+                normalized.detail,
+                "Re-read the issue before retrying the mutation.",
+              );
+            }
+            svc.verifyIssueLabelGroups(
+              plan,
+              actualLabels.map((label) => label.id),
+              mutationSent,
+            );
+            ctx.output.emit(
+              { receipt, resource: detail, priorState: plan.priorState, verified: true },
+              () => {
+                ctx.output.success(
+                  mutationSent
+                    ? `Updated label groups on ${plan.target.identifier}`
+                    : `Label groups already satisfied on ${plan.target.identifier}; no mutation sent`,
+                );
+                ctx.output.success("Verified label groups by authoritative read-back");
+              },
+            );
+            return;
+          }
+          ctx.output.emit(receipt, () => {
+            ctx.output.success(
+              mutationSent
+                ? `Updated label groups on ${plan.target.identifier}`
+                : `Label groups already satisfied on ${plan.target.identifier}; no mutation sent`,
+            );
+          });
+          return;
+        }
+        if (dryRun || fullResult) {
+          throw usageError("--dry-run/--full-result currently require --set-group.");
+        }
+        if (!opts.add && !opts.remove) {
+          throw usageError("Pass --add, --remove, or --set-group GROUP=LABEL.");
+        }
         const updated = await svc.updateIssue(ctx.client, requireId(idArg, ctx.defaultTeam), {
           addLabel: opts.add,
           removeLabel: opts.remove,
@@ -605,6 +808,7 @@ export function registerIssue(program: Command): void {
         );
       }),
     );
+  addAliasOption(labelCommand, "--read-back", "--full-result");
 
   // comment / comments ------------------------------------------------------
   const comment = issue
@@ -1062,6 +1266,89 @@ async function runBulkIssueMutation(
   if (failures > 0) process.exitCode = 1;
 }
 
+function delegationMutationMode(
+  opts: Record<string, any>,
+  delegationChanged: boolean,
+): { dryRun: boolean; fullResult: boolean } {
+  const dryRun = opts.dryRun === true;
+  const fullResult = readAlias<boolean>(opts, "--full-result", "--read-back") === true;
+  if (dryRun && fullResult) {
+    throw usageError("Pass either --dry-run or --full-result, not both.");
+  }
+  // #42 owns general mutation preview/read-back. This bounded slice exposes
+  // the modes only when #45's delegateId is actually part of the mutation.
+  if ((dryRun || fullResult) && !delegationChanged) {
+    throw usageError("--dry-run/--full-result currently require --delegate or --clear-delegate.");
+  }
+  return { dryRun, fullResult };
+}
+
+function emitMutationPreview(ctx: Context, plan: svc.IssueMutationPlan): void {
+  const value = {
+    operation: plan.operation,
+    dryRun: true,
+    target: plan.target,
+    input: plan.input,
+  };
+  ctx.output.detail(value, [
+    ["Operation", plan.operation],
+    ["Dry run", "yes (no mutation sent)"],
+    ["Target", plan.target?.identifier ?? null],
+    ["Input", `\n${JSON.stringify(plan.input, null, 2)}`],
+  ]);
+}
+
+function emitIssueLabelGroupPreview(ctx: Context, plan: svc.IssueLabelGroupPlan): void {
+  const value = {
+    operation: plan.operation,
+    dryRun: true,
+    target: plan.target,
+    input: plan.input,
+    changed: plan.changed,
+    mutationSent: false,
+    groups: plan.groups,
+  };
+  ctx.output.detail(value, [
+    ["Operation", plan.operation],
+    ["Dry run", "yes (no mutation sent)"],
+    ["Target", plan.target.identifier],
+    ["Changed", plan.changed ? "yes" : "no"],
+    ["Input", `\n${JSON.stringify(plan.input, null, 2)}`],
+  ]);
+}
+
+async function emitDelegationResult(
+  ctx: Context,
+  issue: { id: string; identifier: string },
+  plan: svc.IssueMutationPlan,
+  fullResult: boolean,
+  verb: string,
+): Promise<void> {
+  // Read through the same canonical mapper as `issue view`; this is both the
+  // relationship receipt source and the full-result verification boundary.
+  let detail: svc.IssueDetail;
+  try {
+    detail = await svc.getIssueDetail(ctx.client, issue.id, { includeComments: false });
+  } catch (err) {
+    const normalized = normalizeError(err);
+    throw new CliError(
+      `Issue mutation succeeded, but delegation read-back failed: ${normalized.message}. The write may have committed.`,
+      normalized.code,
+      normalized.detail,
+      "Re-read the issue before retrying the mutation.",
+    );
+  }
+  svc.verifyIssueDelegate(detail, plan.input);
+  const receipt = svc.issueDelegationReceipt(detail);
+  const value = fullResult ? { receipt, resource: detail, verified: true } : receipt;
+  ctx.output.emit(value, () => {
+    ctx.output.success(`${verb} ${detail.identifier}`);
+    ctx.output.info(`Assignee: ${detail.assignee?.displayName ?? "none"}`);
+    ctx.output.info(`Delegate: ${detail.delegate?.displayName ?? "none"}`);
+    if (fullResult) ctx.output.success("Verified delegate by authoritative read-back");
+  });
+}
+
 /**
  * Render a single issue's detail block. Shared by `issue view` and the bare
  * `linear` command so `linear --json` === `issue view <id> --json`.
@@ -1088,6 +1375,7 @@ export async function renderIssueDetail(
     ["State", detail.state?.name ?? null],
     ["Priority", detail.priorityLabel],
     ["Assignee", detail.assignee?.displayName ?? null],
+    ["Delegate", detail.delegate?.displayName ?? null],
     ["Team", team ? `${team.key} ${team.name}` : null],
     ["Project", detail.project?.name ?? null],
     ["Milestone", detail.milestone?.name ?? null],
@@ -1240,6 +1528,19 @@ function oneOrTwo(
   return { value: a };
 }
 
+/**
+ * A lone UUID on `issue delegate` is the agent UUID, because a target issue
+ * without an agent is never a complete mutation. The issue therefore comes
+ * from the branch; two operands remain the explicit issue + agent form.
+ */
+export function delegateOperands(
+  a: string | undefined,
+  b: string | undefined,
+): { idArg?: string; value: string } {
+  if (a !== undefined && b === undefined && isUuid(a)) return { value: a };
+  return oneOrTwo(a, b, "agent");
+}
+
 /**
  * `oneOrTwo`'s sibling for `issue comment [id] [body]`, where the value may
  * legitimately be absent (it can come from --body-file or $EDITOR): a lone

package/src/commands/meta.ts

@@ -12,7 +12,7 @@ import {
   writeCredential,
   probeKeyringCredential,
   adoptKeyringCredential,
-  removeCredential,
+  removeCredentialWithMetadata,
   removeOAuthCredential,
   setDefaultWorkspace,
   listCredentials,
@@ -24,6 +24,7 @@ import {
   defaultProjectConfigPath,
   assertSettableKey,
   setConfigKey,
+  setWorkspaceTeam,
   initProjectConfig,
   SETTABLE_KEYS,
   type SettableKey,
@@ -33,6 +34,7 @@ import { readStdinSync } from "../lib/body.js";
 import { authError, normalizeError, usageError } from "../lib/errors.js";
 import { confirmDestructive, promptSelect } from "../lib/prompt.js";
 import { listTeams } from "../services/team.js";
+import { resolveTeam } from "../lib/resolve.js";
 import { ISSUE_SORTS } from "../services/issue.js";
 import { firstTeam, type Context } from "../context.js";
 import { openUrl } from "../lib/open.js";
@@ -105,6 +107,31 @@ export function setAuthValidationClientFactoryForTests(
   authValidationClientFactory = factory ?? defaultAuthValidationClientFactory;
 }
 
+type WorkspaceTeamValidator = (ctx: Context, workspace: string, team: string) => Promise<string>;
+
+/** Validate that an effective credential and team both belong to the requested workspace. */
+export const validateWorkspaceTeam: WorkspaceTeamValidator = async (ctx, workspace, team) => {
+  const [organization, resolved] = await Promise.all([
+    withRetry(() => ctx.client.organization),
+    resolveTeam(ctx.client, team, undefined),
+  ]);
+  if (organization.urlKey !== workspace) {
+    throw usageError(
+      `--workspace '${workspace}' does not match the credential's workspace '${organization.urlKey}'.`,
+    );
+  }
+  return resolved.key;
+};
+
+let workspaceTeamValidator = validateWorkspaceTeam;
+
+/** Test seam for profile-team validation; production always checks Linear. */
+export function setWorkspaceTeamValidatorForTests(
+  validator: WorkspaceTeamValidator | undefined,
+): void {
+  workspaceTeamValidator = validator ?? validateWorkspaceTeam;
+}
+
 /** Merge the local and global login spellings without silently choosing one. */
 export function selectLoginKey(
   localKey: string | undefined,
@@ -529,7 +556,7 @@ export function registerMeta(program: Command): void {
         const local =
           entry?.credentialType === "oauth-user"
             ? removeOAuthCredential(slug)
-            : { removed: removeCredential(slug), fallbackCredentialType: null };
+            : { ...removeCredentialWithMetadata(slug), fallbackCredentialType: null };
         ctx.output.emit(
           {
             success: true,
@@ -537,11 +564,12 @@ export function registerMeta(program: Command): void {
             removed: local.removed,
             revocation,
             fallbackCredentialType: local.fallbackCredentialType,
+            teamMetadataRemoved: local.teamMetadataRemoved,
           },
           () =>
             local.removed
               ? ctx.output.success(
-                  `Removed workspace '${slug}'.${revocation === "revoked" ? " OAuth access was revoked." : revocation === "already-revoked" ? " OAuth access was already revoked." : ""}${local.fallbackCredentialType ? " The existing personal API-key profile is active again." : ""}`,
+                  `Removed workspace '${slug}'.${revocation === "revoked" ? " OAuth access was revoked." : revocation === "already-revoked" ? " OAuth access was already revoked." : ""}${local.fallbackCredentialType ? " The existing personal API-key profile is active again." : ""}${local.teamMetadataRemoved ? " Its default team metadata was removed." : ""}`,
                 )
               : ctx.output.info(`No credential for workspace '${slug}' to remove.`),
         );
@@ -589,6 +617,7 @@ export function registerMeta(program: Command): void {
             accessToken: redactKey(c.accessToken),
             accessTokenSource: c.accessTokenSource,
             credentialWorkspace: c.credentialWorkspace ?? null,
+            workspaceProfile: c.workspaceProfile ?? null,
             team: c.team ?? null,
             workspace: c.workspace ?? null,
             sort: c.sort,
@@ -601,6 +630,7 @@ export function registerMeta(program: Command): void {
             ["API key", `${redactKey(c.apiKey)} (${c.apiKeySource})`],
             ["OAuth access token", `${redactKey(c.accessToken)} (${c.accessTokenSource})`],
             ["Credential workspace", c.credentialWorkspace ?? "(none)"],
+            ["Workspace profile", c.workspaceProfile ?? "(none)"],
             ["Team", show("team", c.team)],
             ["Workspace", show("workspace", c.workspace)],
             ["Sort", show("sort", c.sort)],
@@ -656,8 +686,8 @@ export function registerMeta(program: Command): void {
   // set ---------------------------------------------------------------------
   config
     .command("set <key> <value>")
-    .description(`Set one project setting (${SETTABLE_KEYS.join(", ")}) in the project config`)
-    .option("--user", "write the user config (~/.config/linear/config.toml) instead")
+    .description(`Set one project or user setting (${SETTABLE_KEYS.join(", ")})`)
+    .option("--user", "write the user config (team + --workspace targets that workspace profile)")
     .option("--path <file>", "write this file instead of the project config in effect")
     .action(
       action(async (ctx: Context, opts, key: string, value: string) => {
@@ -676,10 +706,26 @@ export function registerMeta(program: Command): void {
           // here — or a fresh .linear.toml at the git root if there is none.
           path = ctx.config.projectConfigPath ?? defaultProjectConfigPath();
         }
-        const spelling = setConfigKey(path, key, clean, { mode });
-        ctx.output.emit({ success: true, path, key: spelling, value: clean }, () =>
-          ctx.output.success(`Set ${spelling} = ${JSON.stringify(clean)} in ${path}`),
-        );
+        const profileWorkspace = opts.user && key === "team" ? ctx.options.workspace : undefined;
+        if (profileWorkspace) {
+          let team = clean;
+          if (ctx.config.apiKey || ctx.config.accessToken) {
+            team = await workspaceTeamValidator(ctx, profileWorkspace, clean);
+          }
+          path = setWorkspaceTeam(profileWorkspace, team);
+          ctx.output.emit(
+            { success: true, path, key: "team", value: team, workspace: profileWorkspace },
+            () =>
+              ctx.output.success(
+                `Set team = ${JSON.stringify(team)} for workspace '${profileWorkspace}' in ${path}`,
+              ),
+          );
+        } else {
+          const spelling = setConfigKey(path, key, clean, { mode });
+          ctx.output.emit({ success: true, path, key: spelling, value: clean }, () =>
+            ctx.output.success(`Set ${spelling} = ${JSON.stringify(clean)} in ${path}`),
+          );
+        }
       }),
     );
 }

package/src/commands/notification.ts

@@ -9,9 +9,11 @@ import type { Context } from "../context.js";
 import * as svc from "../services/notification.js";
 import type { Column } from "../output/table.js";
 import { ExitCode } from "../lib/errors.js";
+import { addIncludeArchivedOption } from "../lib/options.js";
+import { lifecycleSuffix } from "../output/lifecycle.js";
 
 const ROW_COLUMNS: Column<svc.NotificationRow>[] = [
-  { key: "type", header: "Type", value: (r) => r.type, max: 24 },
+  { key: "type", header: "Type", value: (r) => `${r.type}${lifecycleSuffix(r)}`, max: 36 },
   { key: "subject", header: "Subject", value: (r) => r.subject ?? "—", max: 50 },
   { key: "read", header: "Read", value: (r) => (r.read ? "✓" : "•") },
   { key: "createdAt", header: "Created", value: (r) => r.createdAt.slice(0, 10) },
@@ -24,17 +26,17 @@ export function registerNotification(program: Command): void {
     .description("Work with your notifications");
 
   // list --------------------------------------------------------------------
-  notification
+  const list = notification
     .command("list")
     .alias("ls")
     .description("List your notifications")
-    .option("--include-archived", "include archived notifications")
     .action(
       action(async (ctx: Context, opts) => {
         const rows = await svc.listNotifications(ctx.client, ctx.limit, !!opts.includeArchived);
         ctx.output.list(rows, ROW_COLUMNS, rows);
       }),
     );
+  addIncludeArchivedOption(list);
 
   // read --------------------------------------------------------------------
   notification