@geraldmaron/construct 1.1.1 → 1.2.1

package/lib/config/intake-policy.mjs

@@ -0,0 +1,209 @@
+/**
+ * lib/config/intake-policy.mjs — project-scoped intake watcher policy.
+ *
+ * Resolves watch zones, scan depth, and additional directories from
+ * construct.config.json intakePolicy, with warned fallback to legacy
+ * .cx/intake-config.json and env overrides.
+ */
+
+import { existsSync, readFileSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { loadProjectConfig, writeProjectConfig, findProjectConfigPath, PROJECT_CONFIG_FILENAME } from './project-config.mjs';
+import {
+  INTAKE_DEFAULT_MAX_DEPTH,
+  INTAKE_HARD_MAX_DEPTH,
+  INTAKE_DEPTH_GUIDANCE,
+  describeIntakeDepth,
+} from '../intake/constants.mjs';
+import { INTAKE_CONFIG_FILE } from '../intake/legacy-paths.mjs';
+
+export { INTAKE_DEFAULT_MAX_DEPTH, INTAKE_HARD_MAX_DEPTH, INTAKE_DEPTH_GUIDANCE, describeIntakeDepth };
+
+export const DEFAULT_INTAKE_POLICY = Object.freeze({
+  maxDepth: INTAKE_DEFAULT_MAX_DEPTH,
+  zones: Object.freeze({
+    rootInbox: true,
+    projectInbox: true,
+    docsIntake: true,
+  }),
+  additionalDirs: [],
+});
+
+function clampDepth(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return INTAKE_DEFAULT_MAX_DEPTH;
+  return Math.min(Math.floor(n), INTAKE_HARD_MAX_DEPTH);
+}
+
+function normalizeDir(dir, rootDir) {
+  if (typeof dir !== 'string') return null;
+  const trimmed = dir.trim();
+  if (!trimmed) return null;
+  return isAbsolute(trimmed) ? trimmed : resolve(rootDir, trimmed);
+}
+
+function parseEnvDirs(env) {
+  const raw = String(env?.CX_INBOX_DIRS ?? '').trim();
+  if (!raw) return [];
+  return raw.split(':').map((p) => p.trim()).filter(Boolean);
+}
+
+function readLegacyIntakeConfig(rootDir) {
+  const file = join(rootDir, INTAKE_CONFIG_FILE);
+  if (!existsSync(file)) return null;
+  try {
+    return JSON.parse(readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function intakePolicyFromProjectConfig(config) {
+  const raw = config?.intakePolicy ?? {};
+  const zones = raw.zones ?? {};
+  return {
+    maxDepth: clampDepth(raw.maxDepth ?? DEFAULT_INTAKE_POLICY.maxDepth),
+    zones: {
+      rootInbox: zones.rootInbox !== false,
+      projectInbox: zones.projectInbox !== false,
+      docsIntake: zones.docsIntake !== false,
+    },
+    additionalDirs: Array.isArray(raw.additionalDirs)
+      ? raw.additionalDirs.map((d) => String(d).trim()).filter(Boolean)
+      : [],
+  };
+}
+
+export function legacyIntakeToPolicy(stored = {}) {
+  return {
+    maxDepth: clampDepth(stored.maxDepth ?? INTAKE_DEFAULT_MAX_DEPTH),
+    zones: {
+      rootInbox: stored.includeArchetypeInbox === true || stored.includeRootInbox === true,
+      projectInbox: stored.includeProjectInbox !== false,
+      docsIntake: stored.includeDocsIntake !== false,
+    },
+    additionalDirs: Array.isArray(stored.parentDirs) ? stored.parentDirs : [],
+  };
+}
+
+export function policyToLegacyIntakeShape(policy) {
+  return {
+    parentDirs: policy.additionalDirs,
+    maxDepth: policy.maxDepth,
+    includeProjectInbox: policy.zones.projectInbox,
+    includeDocsIntake: policy.zones.docsIntake,
+    includeArchetypeInbox: policy.zones.rootInbox,
+    includeRootInbox: policy.zones.rootInbox,
+  };
+}
+
+export function loadIntakePolicy(rootDir, env = process.env) {
+  const { config, path: configPath, raw } = loadProjectConfig(rootDir, env);
+  const legacy = readLegacyIntakeConfig(rootDir);
+  let policy;
+  let source = 'default';
+  let legacyWarning = null;
+
+  if (configPath && raw?.intakePolicy) {
+    policy = intakePolicyFromProjectConfig(config);
+    source = 'project-config';
+  } else if (legacy) {
+    policy = legacyIntakeToPolicy(legacy);
+    source = 'legacy-intake-config';
+    legacyWarning = `Using deprecated ${INTAKE_CONFIG_FILE}; migrate with \`construct intake config migrate\``;
+  } else {
+    policy = structuredClone(DEFAULT_INTAKE_POLICY);
+    source = 'default';
+  }
+
+  const envDirs = parseEnvDirs(env).map((dir) => normalizeDir(dir, rootDir)).filter(Boolean);
+  const additionalDirs = []
+    .concat(policy.additionalDirs.map((dir) => normalizeDir(dir, rootDir)).filter(Boolean))
+    .concat(envDirs);
+
+  const seen = new Set();
+  const uniqueDirs = [];
+  for (const dir of additionalDirs) {
+    if (seen.has(dir)) continue;
+    seen.add(dir);
+    uniqueDirs.push(dir);
+  }
+
+  const envDepth = env?.CX_INTAKE_MAX_DEPTH;
+  const maxDepth = clampDepth(envDepth ?? policy.maxDepth);
+
+  return {
+    maxDepth,
+    zones: { ...policy.zones },
+    additionalDirs: uniqueDirs,
+    source,
+    legacyWarning,
+  };
+}
+
+export function resolvedIntakeConfig(rootDir, env = process.env) {
+  const policy = loadIntakePolicy(rootDir, env);
+  return {
+    parentDirs: policy.additionalDirs,
+    maxDepth: policy.maxDepth,
+    includeProjectInbox: policy.zones.projectInbox,
+    includeDocsIntake: policy.zones.docsIntake,
+    includeArchetypeInbox: policy.zones.rootInbox,
+    includeRootInbox: policy.zones.rootInbox,
+    source: policy.source,
+    legacyWarning: policy.legacyWarning,
+  };
+}
+
+export function saveIntakePolicy(rootDir, patch = {}, options = {}) {
+  const configPath = findProjectConfigPath(rootDir) ?? join(rootDir, PROJECT_CONFIG_FILENAME);
+  const { config } = loadProjectConfig(rootDir, {});
+  const current = intakePolicyFromProjectConfig(config.intakePolicy ? config : { intakePolicy: DEFAULT_INTAKE_POLICY });
+
+  const nextZones = { ...current.zones, ...(patch.zones ?? {}) };
+  const next = {
+    maxDepth: clampDepth(patch.maxDepth ?? current.maxDepth),
+    zones: {
+      rootInbox: patch.rootInbox !== undefined ? Boolean(patch.rootInbox) : (patch.zones?.rootInbox ?? nextZones.rootInbox),
+      projectInbox: patch.projectInbox !== undefined ? Boolean(patch.projectInbox) : (patch.zones?.projectInbox ?? nextZones.projectInbox),
+      docsIntake: patch.docsIntake !== undefined ? Boolean(patch.docsIntake) : (patch.zones?.docsIntake ?? nextZones.docsIntake),
+    },
+    additionalDirs: Array.isArray(patch.additionalDirs)
+      ? patch.additionalDirs.map((dir) => normalizeDir(dir, rootDir)).filter(Boolean)
+      : current.additionalDirs,
+  };
+
+  if (patch.addDir) {
+    const dir = normalizeDir(patch.addDir, rootDir);
+    if (dir && !next.additionalDirs.includes(dir)) {
+      next.additionalDirs = [...next.additionalDirs, dir];
+    }
+  }
+  if (patch.removeDir) {
+    const dir = normalizeDir(patch.removeDir, rootDir);
+    next.additionalDirs = next.additionalDirs.filter((d) => d !== dir);
+  }
+
+  const updated = {
+    ...config,
+    version: config.version ?? 1,
+    intakePolicy: next,
+  };
+
+  if (options.dryRun) {
+    return { policy: next, configPath, dryRun: true };
+  }
+
+  writeProjectConfig(configPath, updated);
+  return { policy: next, configPath };
+}
+
+export function migrateLegacyIntakeConfig(rootDir) {
+  const legacy = readLegacyIntakeConfig(rootDir);
+  if (!legacy) {
+    return { migrated: false, reason: 'no legacy file' };
+  }
+  const policy = legacyIntakeToPolicy(legacy);
+  saveIntakePolicy(rootDir, policy);
+  return { migrated: true, policy };
+}

package/lib/config/project-config.mjs

@@ -15,6 +15,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { CONFIG_SCHEMA_VERSION, DEFAULT_PROJECT_CONFIG, validateProjectConfig, FIELD_RULES } from './schema.mjs';
+import { validateSourceTargets } from './source-targets.mjs';
 
 export const PROJECT_CONFIG_FILENAME = 'construct.config.json';
 
@@ -85,13 +86,17 @@ export function loadProjectConfig(cwd = process.cwd(), env = process.env) {
     };
   }
   const validation = validateProjectConfig(raw);
-  if (!validation.valid) {
+  const targetErrors = raw?.sources?.targets !== undefined
+    ? validateSourceTargets(raw.sources.targets)
+    : [];
+  const allErrors = [...(validation.errors ?? []), ...targetErrors];
+  if (!validation.valid || targetErrors.length) {
     return {
       path: configPath,
       raw,
       config: structuredClone(DEFAULT_PROJECT_CONFIG),
       source: 'invalid',
-      errors: validation.errors,
+      errors: allErrors,
     };
   }
   const merged = deepMerge(structuredClone(DEFAULT_PROJECT_CONFIG), raw);
@@ -161,6 +166,10 @@ export function writeProjectConfig(filePath, config, options = {}) {
   let validation = { valid: true, errors: [] };
   if (validate) {
     validation = validateProjectConfig(config);
+    if (config?.sources?.targets !== undefined) {
+      validation.errors = [...(validation.errors ?? []), ...validateSourceTargets(config.sources.targets)];
+      validation.valid = validation.errors.length === 0;
+    }
   }
   
   // Combine all errors (handle case where validation.errors is undefined)

package/lib/config/schema.mjs

@@ -5,7 +5,8 @@
  * AJV/zod to keep Construct dependency-free at startup — the loader runs
  * before npm install completes in some bootstrap paths.
  *
- * Schema v1 covers: alias, deployment, providers, autoEmbed, ingest, telemetry.
+ * Schema v1 covers: alias, deployment, providers, sources, intakePolicy,
+ * autoEmbed, ingest, telemetry.
  * Tier model selection lives in `specialists/registry.json` only — this config
  * file is intentionally not a second edit surface for model assignments.
  * Later phases (6, 7b) extend it with `resources` and `costs` blocks
@@ -47,6 +48,22 @@ export const DEFAULT_PROJECT_CONFIG = Object.freeze({
     tenantId: null,
   }),
   providers: Object.freeze({}),
+  sources: Object.freeze({
+    targets: [],
+  }),
+  intakePolicy: Object.freeze({
+    maxDepth: 4,
+    zones: Object.freeze({
+      rootInbox: true,
+      projectInbox: true,
+      docsIntake: true,
+    }),
+    additionalDirs: [],
+  }),
+  artifactWorkflow: Object.freeze({
+    defaults: Object.freeze({}),
+    types: Object.freeze({}),
+  }),
   profile: DEFAULT_PROFILE_ID,
   autoEmbed: false,
   ingest: Object.freeze({
@@ -65,6 +82,18 @@ export const DEFAULT_PROJECT_CONFIG = Object.freeze({
   hooks: Object.freeze({
     outputMode: 'auto',
   }),
+  models: Object.freeze({
+    visibility: Object.freeze({
+      mode: 'all_configured',
+      include: [],
+      exclude: [],
+      providers: {},
+    }),
+    catalog: Object.freeze({
+      liveOpenRouter: true,
+      maxLiveFree: 24,
+    }),
+  }),
   roleSelection: Object.freeze({
     primary: null,
     secondary: null,
@@ -109,6 +138,38 @@ export const FIELD_RULES = {
     },
   },
   providers: { type: 'object', required: false },
+  sources: {
+    type: 'object',
+    required: false,
+    fields: {
+      targets: { type: 'array' },
+    },
+  },
+  intakePolicy: {
+    type: 'object',
+    required: false,
+    fields: {
+      maxDepth: { type: 'number' },
+      additionalDirs: { type: 'array' },
+      zones: {
+        type: 'object',
+        required: false,
+        fields: {
+          rootInbox: { type: 'boolean' },
+          projectInbox: { type: 'boolean' },
+          docsIntake: { type: 'boolean' },
+        },
+      },
+    },
+  },
+  artifactWorkflow: {
+    type: 'object',
+    required: false,
+    fields: {
+      defaults: { type: 'object', required: false },
+      types: { type: 'object', required: false },
+    },
+  },
   profile: { type: 'string', required: false, maxLength: 40 },
   autoEmbed: { type: 'boolean', required: false },
   ingest: {
@@ -171,14 +232,33 @@ export const FIELD_RULES = {
       billingMode: { type: 'string', enum: ['metered', 'subscription', 'mixed'] },
       enforce: { type: 'boolean' },
       budgets: { type: 'object' },
-      // Per-provider billing-mode overrides. The global billingMode is the
-      // fallback; entries here win for the provider id (anthropic, openai,
-      // openrouter, gemini, ollama, local, github-copilot, …). Subscription
-      // entries contribute $0 to "actual spend" headline numbers; the
-      // metered-equivalent stays in the footnote.
       providers: { type: 'object', required: false },
     },
   },
+  models: {
+    type: 'object',
+    required: false,
+    fields: {
+      visibility: {
+        type: 'object',
+        required: false,
+        fields: {
+          mode: { type: 'string', enum: ['all_configured', 'tier_defaults', 'explicit'] },
+          include: { type: 'array' },
+          exclude: { type: 'array' },
+          providers: { type: 'object' },
+        },
+      },
+      catalog: {
+        type: 'object',
+        required: false,
+        fields: {
+          liveOpenRouter: { type: 'boolean' },
+          maxLiveFree: { type: 'number' },
+        },
+      },
+    },
+  },
 };
 
 function checkType(value, expected) {

package/lib/config/source-targets.mjs

@@ -0,0 +1,311 @@
+/**
+ * lib/config/source-targets.mjs — typed integration source targets in construct.config.json.
+ *
+ * Validates GitHub, Jira, Linear, and Slack selector records, merges legacy env
+ * target lists additively, deduplicates by provider+selector signature, and
+ * converts resolved targets into embed provider source records for auto-discovery.
+ */
+
+export const SOURCE_PROVIDERS = Object.freeze(['github', 'jira', 'linear', 'slack']);
+
+export const SLACK_INTENTS = Object.freeze(['internal', 'risk', 'decision', 'external', 'how-to']);
+
+const ID_RE = /^[a-z][a-z0-9_-]{0,63}$/i;
+const GITHUB_REPO_RE = /^[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+$/;
+const JIRA_PROJECT_RE = /^[A-Z][A-Z0-9]{1,9}$/;
+
+export function validateSourceTarget(target, index = 0) {
+  const errors = [];
+  const at = `sources.targets[${index}]`;
+
+  if (!target || typeof target !== 'object' || Array.isArray(target)) {
+    return [`${at}: must be an object`];
+  }
+
+  if (typeof target.id !== 'string' || !ID_RE.test(target.id)) {
+    errors.push(`${at}.id: required stable id (letters, numbers, hyphens, underscores; max 64 chars)`);
+  }
+
+  if (!SOURCE_PROVIDERS.includes(target.provider)) {
+    errors.push(`${at}.provider: must be one of ${SOURCE_PROVIDERS.join(', ')}`);
+  }
+
+  if (!target.selector || typeof target.selector !== 'object' || Array.isArray(target.selector)) {
+    errors.push(`${at}.selector: required object`);
+    return errors;
+  }
+
+  const sel = target.selector;
+  switch (target.provider) {
+    case 'github':
+      if (typeof sel.repo !== 'string' || !GITHUB_REPO_RE.test(sel.repo.trim())) {
+        errors.push(`${at}.selector.repo: required owner/repo slug`);
+      }
+      break;
+    case 'jira':
+      if (typeof sel.project !== 'string' || !JIRA_PROJECT_RE.test(sel.project.trim().toUpperCase())) {
+        errors.push(`${at}.selector.project: required Jira project key (2–10 uppercase letters/digits)`);
+      }
+      break;
+    case 'linear':
+      if (typeof sel.team !== 'string' || !sel.team.trim()) {
+        errors.push(`${at}.selector.team: required Linear team key or name`);
+      }
+      break;
+    case 'slack': {
+      if (typeof sel.channel !== 'string' || !sel.channel.trim()) {
+        errors.push(`${at}.selector.channel: required Slack channel name or ID`);
+      }
+      if (sel.intent !== undefined && !SLACK_INTENTS.includes(sel.intent)) {
+        errors.push(`${at}.selector.intent: must be one of ${SLACK_INTENTS.join(', ')}`);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+
+  return errors;
+}
+
+export function validateSourceTargets(targets) {
+  const errors = [];
+  if (targets === undefined) return errors;
+  if (!Array.isArray(targets)) {
+    return ['sources.targets: must be an array'];
+  }
+
+  const seenIds = new Set();
+  for (let i = 0; i < targets.length; i++) {
+    errors.push(...validateSourceTarget(targets[i], i));
+    const id = targets[i]?.id;
+    if (typeof id === 'string') {
+      const key = id.toLowerCase();
+      if (seenIds.has(key)) {
+        errors.push(`sources.targets[${i}].id: duplicate id "${id}"`);
+      }
+      seenIds.add(key);
+    }
+  }
+  return errors;
+}
+
+function parseCsv(value) {
+  return String(value ?? '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+function slugId(value) {
+  return String(value).toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+}
+
+function parseSlackChannelEntry(raw) {
+  const trimmed = String(raw).trim().replace(/^#/, '');
+  const colon = trimmed.indexOf(':');
+  if (colon === -1) {
+    return { channel: trimmed, intent: 'internal' };
+  }
+  return { channel: trimmed.slice(0, colon), intent: trimmed.slice(colon + 1) || 'internal' };
+}
+
+export function legacyEnvSourceTargets(env = process.env) {
+  const targets = [];
+
+  for (const repo of parseCsv(env.GITHUB_REPOS ?? env.GITHUB_REPO)) {
+    targets.push({
+      id: `env-github-${slugId(repo)}`,
+      provider: 'github',
+      selector: { repo },
+      provenance: 'env:GITHUB_REPOS',
+    });
+  }
+
+  for (const project of parseCsv(env.JIRA_PROJECTS)) {
+    const key = project.toUpperCase();
+    targets.push({
+      id: `env-jira-${slugId(key)}`,
+      provider: 'jira',
+      selector: { project: key },
+      provenance: 'env:JIRA_PROJECTS',
+    });
+  }
+
+  for (const team of parseCsv(env.LINEAR_TEAMS)) {
+    targets.push({
+      id: `env-linear-${slugId(team)}`,
+      provider: 'linear',
+      selector: { team },
+      provenance: 'env:LINEAR_TEAMS',
+    });
+  }
+
+  for (const entry of parseCsv(env.SLACK_CHANNELS ?? env.SLACK_CHANNEL)) {
+    const { channel, intent } = parseSlackChannelEntry(entry);
+    targets.push({
+      id: `env-slack-${slugId(channel)}`,
+      provider: 'slack',
+      selector: { channel, intent: SLACK_INTENTS.includes(intent) ? intent : 'internal' },
+      provenance: 'env:SLACK_CHANNELS',
+    });
+  }
+
+  return targets;
+}
+
+export function targetSignature(target) {
+  const sel = target.selector ?? {};
+  switch (target.provider) {
+    case 'github':
+      return `github:repo:${sel.repo?.trim().toLowerCase()}`;
+    case 'jira':
+      return `jira:project:${String(sel.project ?? '').trim().toUpperCase()}`;
+    case 'linear':
+      return `linear:team:${String(sel.team ?? '').trim().toLowerCase()}`;
+    case 'slack':
+      return `slack:channel:${String(sel.channel ?? '').trim().toLowerCase()}:intent:${sel.intent ?? 'internal'}`;
+    default:
+      return `${target.provider}:${JSON.stringify(sel)}`;
+  }
+}
+
+export function mergeSourceTargets(configTargets = [], envTargets = []) {
+  const merged = [];
+  const seen = new Set();
+
+  for (const target of [...configTargets, ...envTargets]) {
+    const sig = targetSignature(target);
+    if (seen.has(sig)) continue;
+    seen.add(sig);
+    merged.push(target);
+  }
+  return merged;
+}
+
+export function normalizeConfigTarget(raw) {
+  const out = {
+    id: String(raw.id).trim(),
+    provider: raw.provider,
+    selector: { ...raw.selector },
+    provenance: raw.provenance ?? 'config',
+  };
+
+  if (out.provider === 'jira' && out.selector.project) {
+    out.selector.project = String(out.selector.project).trim().toUpperCase();
+  }
+  if (out.provider === 'github' && out.selector.repo) {
+    out.selector.repo = String(out.selector.repo).trim();
+  }
+  if (out.provider === 'linear' && out.selector.team) {
+    out.selector.team = String(out.selector.team).trim();
+  }
+  if (out.provider === 'slack' && out.selector.channel) {
+    out.selector.channel = String(out.selector.channel).trim().replace(/^#/, '');
+    if (!out.selector.intent) out.selector.intent = 'internal';
+  }
+  return out;
+}
+
+export function resolveEffectiveSourceTargetsFromConfig(config, env = process.env) {
+  const configTargets = (config?.sources?.targets ?? []).map(normalizeConfigTarget);
+  const envTargets = legacyEnvSourceTargets(env);
+  return mergeSourceTargets(configTargets, envTargets);
+}
+
+export function targetsToEmbedSources(targets) {
+  const sources = [];
+  const githubRepos = targets.filter((t) => t.provider === 'github').map((t) => t.selector.repo);
+  if (githubRepos.length) {
+    sources.push({
+      provider: 'github',
+      repos: githubRepos,
+      refs: ['prs', 'issues', 'commits'],
+      limit: 25,
+    });
+    sources.push({
+      provider: 'github',
+      repos: githubRepos,
+      refs: ['meta', 'readme', 'docs'],
+      limit: 25,
+    });
+  }
+
+  for (const target of targets.filter((t) => t.provider === 'jira')) {
+    sources.push({
+      provider: 'jira',
+      project: target.selector.project,
+      refs: ['issues'],
+      limit: 50,
+    });
+  }
+
+  for (const target of targets.filter((t) => t.provider === 'linear')) {
+    sources.push({
+      provider: 'linear',
+      team: target.selector.team,
+      refs: ['issues'],
+      limit: 50,
+    });
+  }
+
+  const slackByIntent = new Map();
+  for (const target of targets.filter((t) => t.provider === 'slack')) {
+    const intent = target.selector.intent ?? 'internal';
+    if (!slackByIntent.has(intent)) slackByIntent.set(intent, []);
+    slackByIntent.get(intent).push(target.selector.channel);
+  }
+  for (const [intent, channels] of slackByIntent) {
+    sources.push({
+      provider: 'slack',
+      channels,
+      intent,
+      refs: ['messages'],
+      oldest: 86400,
+      limit: 50,
+    });
+  }
+
+  return sources;
+}
+
+export function resolveKnownSourcesFromTargets(targets) {
+  const sources = [];
+
+  for (const target of targets) {
+    const sel = target.selector ?? {};
+    if (target.provider === 'github' && sel.repo) {
+      const repo = sel.repo;
+      const short = repo.split('/').pop();
+      sources.push({ id: repo.toLowerCase(), provider: 'github', ref: repo, display: repo, targetId: target.id });
+      sources.push({ id: short.toLowerCase(), provider: 'github', ref: repo, display: repo, targetId: target.id });
+      sources.push({ id: short.replace(/-/g, '').toLowerCase(), provider: 'github', ref: repo, display: repo, targetId: target.id });
+      const words = short.split('-');
+      if (words.length > 1) {
+        sources.push({ id: words[words.length - 1].toLowerCase(), provider: 'github', ref: repo, display: repo, targetId: target.id });
+      }
+    }
+    if (target.provider === 'jira' && sel.project) {
+      const key = sel.project;
+      sources.push({ id: key.toLowerCase(), provider: 'jira', ref: key, display: `Jira/${key}`, targetId: target.id });
+    }
+    if (target.provider === 'linear' && sel.team) {
+      const team = sel.team;
+      sources.push({ id: team.toLowerCase(), provider: 'linear', ref: team, display: `Linear/${team}`, targetId: target.id });
+    }
+    if (target.provider === 'slack' && sel.channel) {
+      const ch = sel.channel;
+      sources.push({ id: ch.toLowerCase(), provider: 'slack', ref: ch, display: `Slack/${ch}`, targetId: target.id });
+    }
+  }
+
+  const providers = new Set(targets.map((t) => t.provider));
+  if (providers.has('jira')) {
+    sources.push({ id: 'jira', provider: 'jira', ref: null, display: 'Jira' });
+  }
+  if (providers.has('linear')) {
+    sources.push({ id: 'linear', provider: 'linear', ref: null, display: 'Linear' });
+  }
+
+  return sources;
+}