loreli 1.0.0 → 2.0.0

package/packages/mcp/src/tools/start.js

@@ -9,6 +9,7 @@ import { ENTRY, CODEX_TOML, prune as pruneWorkspaces } from 'loreli/workspace';
 import { Tmux } from 'loreli/tmux';
 import { responder } from 'loreli/workflow';
 import { capability } from 'loreli/identity';
+import { select } from './repo.js';
 
 const log = logger('start');
 
@@ -53,8 +54,7 @@ export default {
           type: 'array', items: { type: 'string' },
           description: 'GitHub usernames for Human In The Loop. Empty = auto-merge.'
         }
-      },
-      required: ['repo']
+      }
     },
     /**
      * @param {object} args - Tool arguments.
@@ -62,9 +62,14 @@ export default {
      * @returns {Promise<object>} Start result with environment info and templates.
      */
     async exec(args, ctx) {
-      check.repo(args.repo);
       if (args.theme) check.theme(args.theme);
-      const { repo } = args;
+      const repo = select(args.repo, ctx);
+      if (!repo) {
+        return {
+          content: [{ type: 'text', text: 'No repository configured. Pass --repo, set LORELI_REPO, or set repo in loreli.yml.' }],
+          isError: true
+        };
+      }
 
       // Agent MCP servers (spawned from .mcp.json by Claude Code, Codex, etc.)
       // are hydrated from env vars during _hydrate(). If a session ID is
@@ -92,21 +97,9 @@ export default {
         ctx.hub = createHub({ config: ctx.config });
       }
 
-      // 1. Discover environment
+      // 1. Discover environment + existing files in parallel
       const backendRegistry = ctx.backendRegistry;
-      await backendRegistry.discover();
-      const backends = backendRegistry.available();
-      const providers = backendRegistry.providers();
-      const sideInfo = capability(providers);
 
-      // Determine review strategy
-      let strategy = 'error';
-      if (sideInfo.mode === 'dual') strategy = 'yin-yang';
-      else if (sideInfo.mode === 'single') strategy = 'fresh-instance';
-
-      log.info(`backends: ${backends.map(function name(b) { return b.name; }).join(', ') || 'none'}, strategy: ${strategy}`);
-
-      // 2. Discover existing files (inlined from hub.discover)
       const templates = { pr: null, issue: null, codeowners: null, contributing: null, config: null };
       const checks = [
         ['.github/pull_request_template.md', 'pr'],
@@ -118,13 +111,27 @@ export default {
         ['.agents/skills/loreli-context/SKILL.md', 'contextSkill']
       ];
 
-      for (const [path, key] of checks) {
-        try {
-          await ctx.hub.read(repo, path);
-          templates[key] = path;
-        } catch { /* not found */ }
+      const [/* discover result */, ...fileResults] = await Promise.all([
+        backendRegistry.discover(),
+        ...checks.map(function probe([path]) {
+          return ctx.hub.read(repo, path).then(function found() { return path; }, function miss() { return null; });
+        })
+      ]);
+
+      for (let i = 0; i < checks.length; i += 1) {
+        if (fileResults[i]) templates[checks[i][1]] = fileResults[i];
       }
 
+      const backends = backendRegistry.available();
+      const providers = backendRegistry.providers();
+      const sideInfo = capability(providers);
+
+      let strategy = 'error';
+      if (sideInfo.mode === 'dual') strategy = 'yin-yang';
+      else if (sideInfo.mode === 'single') strategy = 'fresh-instance';
+
+      log.info(`backends: ${backends.map(function name(b) { return b.name; }).join(', ') || 'none'}, strategy: ${strategy}`);
+
       // 3. Scaffold any missing required files
       const scaffolded = [];
       const toScaffold = [];
@@ -158,27 +165,15 @@ export default {
         }
       }
 
-      // Ensure loreli is in devDependencies so agents can resolve
-      // `npx loreli mcp` from the cloned repo after npm install.
-      // Handles both cases: no package.json, and existing package.json
-      // that doesn't list loreli yet. Reads the existing file (if any),
-      // merges the devDependency, and writes back.
-      await ensureDependency(ctx.hub, repo, scaffolded);
-
-      // Ensure MCP configs exist with the loreli server entry for each
-      // supported agent CLI (Claude, Cursor, Codex). Config paths come
-      // from the backend registry so adding a backend doesn't require
-      // touching this tool.
-      await ensureMcpConfigs(ctx.hub, repo, scaffolded, backendRegistry.configPaths());
-
-      // Ensure .gitignore contains Loreli artifact entries so agent-
-      // generated files (.loreli/, .claude/, .cursor/hooks.json) never
-      // leak into PRs. Creates the file if absent, appends if present.
-      await ensureGitignore(ctx.hub, repo, scaffolded);
-
-      // 4. Load config from loreli.yml (guaranteed to exist after scaffolding)
+      // Run ensure* operations and config load in parallel — each
+      // targets different files so there are no ordering dependencies.
       const config = new Config();
-      await config.load(ctx.hub, repo);
+      await Promise.all([
+        ensureDependency(ctx.hub, repo, scaffolded),
+        ensureMcpConfigs(ctx.hub, repo, scaffolded, backendRegistry.configPaths()),
+        ensureGitignore(ctx.hub, repo, scaffolded),
+        config.load(ctx.hub, repo)
+      ]);
 
       // 5. Merge start param overrides
       const overrides = {};
@@ -188,11 +183,12 @@ export default {
 
       const theme = config.get('theme');
       const mergeBase = config.get('merge.base') ?? 'main';
-      const baseProvision = await ensureMergeBase(ctx.hub, repo, mergeBase);
 
-      // 6. Ensure agent labels exist in the repo
+      // 6. Ensure merge base and labels in parallel — both depend on
+      // config but are independent of each other.
       let ensuredLabels = [];
-      if (config.get('labels.track') !== false) {
+      const labelPromise = (async function ensureLabels() {
+        if (config.get('labels.track') === false) return [];
         const labelNames = [
           'loreli',
           'loreli:planner', 'loreli:action', 'loreli:reviewer',
@@ -203,13 +199,18 @@ export default {
             labelNames.push(`loreli:${backend.provider}`);
           }
         }
-        // Include user-configured extra labels
         const extra = config.get('labels.extra') ?? [];
         for (const name of extra) labelNames.push(name);
 
         const unique = [...new Set(labelNames)];
-        ensuredLabels = await ctx.hub.ensure(repo, definitions(unique));
-      }
+        return ctx.hub.ensure(repo, definitions(unique));
+      })();
+
+      const [baseProvision, labels] = await Promise.all([
+        ensureMergeBase(ctx.hub, repo, mergeBase),
+        labelPromise
+      ]);
+      ensuredLabels = labels;
 
       // 7. Initialize session storage
       const sessionId = `${repo.replace('/', '-')}-${Date.now()}`;
@@ -314,56 +315,34 @@ export default {
       }
 
       // Knowledge reactor — detect recurring feedback patterns and
-      // propose promotions via discussions when threshold is met.
+      // dispatch planning via planner when threshold is met.
       if (ctx.orchestrator && ctx.hub) {
         ctx.orchestrator.register('knowledge', async function knowledge(repo) {
           const cfg = ctx.orchestrator.cfg;
-          const enabled = cfg?.get?.('feedback.enabled') ?? true;
-          if (!enabled) return;
+          if (!(cfg?.get?.('feedback.enabled') ?? true)) return;
 
           const threshold = cfg?.get?.('feedback.threshold') ?? 5;
-          const categories = cfg?.get?.('feedback.categories');
-          const { patterns, propose } = await import('loreli/knowledge');
-          const found = await patterns(ctx.hub, repo, { threshold, category: categories?.[0] });
+          const { patterns, objective } = await import('loreli/knowledge');
 
-          for (const pattern of found) {
-            const existing = await ctx.hub.searchIssues(repo, `Promotion: ${pattern.category}`);
-            const duplicate = existing.some(function match(i) { return i.title.includes(pattern.fingerprint); });
-            if (duplicate) continue;
+          const found = await patterns(ctx.hub, repo, { threshold });
 
-            await propose(ctx.hub, repo, pattern);
-          }
-        });
-      }
+          const cat = await ctx.hub.category(repo, 'Loreli');
+          const discussions = await ctx.hub.discussions(repo, cat.id);
+          const openTitles = new Set(
+            discussions.filter(function open(d) { return !d.closed; })
+              .map(function title(d) { return d.title; })
+          );
 
-      // Promotion approval — scan closed promotion discussions for
-      // human-approved patterns and create action issues.
-      if (ctx.orchestrator && ctx.hub) {
-        ctx.orchestrator.register('promotion-apply', async function promotionApply(repo) {
-          const cfg = ctx.orchestrator.cfg;
-          if (!(cfg?.get?.('feedback.enabled') ?? true)) return;
+          for (const pattern of found) {
+            const title = `${pattern.category} feedback pattern`;
+            if (openTitles.has(title) || ctx._feedbackDispatched?.has(pattern.category)) continue;
 
-          const { parse } = await import('loreli/marker');
-          const { apply } = await import('loreli/knowledge');
-          const discussions = await ctx.hub.searchIssues(repo, 'loreli:promotion status:closed');
-
-          for (const disc of discussions) {
-            if (disc.type !== 'issue') continue;
-            try {
-              const full = await ctx.hub.read(repo, disc.number);
-              const data = parse(full.body, 'promotion');
-              if (!data || data.status === 'applied') continue;
-
-              const approved = /- \[x\]\s*Approve/i.test(full.body);
-              const rejected = /- \[x\]\s*Reject/i.test(full.body);
-              if (!approved || rejected) continue;
-
-              await apply(ctx.hub, repo, {
-                summary: `${data.category} standard`,
-                discussion: disc.number,
-                body: full.body
-              });
-            } catch { /* non-fatal */ }
+            await ctx.planner.plan(repo, objective(pattern), {
+              feedbackCategory: pattern.category
+            });
+
+            ctx._feedbackDispatched ??= new Set();
+            ctx._feedbackDispatched.add(pattern.category);
           }
         });
       }
@@ -605,7 +584,7 @@ async function pause(ms, wait) {
   });
 }
 
-export { ensureMergeBase };
+export { ensureMergeBase, normalizeCodexEnvVars };
 
 /**
  * Ensure `loreli` exists in the target repo's devDependencies.
@@ -623,8 +602,85 @@ export { ensureMergeBase };
  */
 // MCP config constants (ENTRY, CODEX_TOML) imported from @loreli/workspace
 // LORELI_TOML needs a leading newline for appending to existing TOML files
+const CODEX_ENV_VARS = 'env_vars = ["GITHUB_TOKEN"]';
 const LORELI_TOML = `\n${CODEX_TOML}`;
 
+/**
+ * Find the next TOML table header index at or after `start`.
+ *
+ * @param {string[]} lines - TOML content split by line.
+ * @param {number} start - Start index.
+ * @returns {number} Index of next table header or lines.length.
+ */
+function nextTomlTable(lines, start) {
+  for (let index = start; index < lines.length; index += 1) {
+    if (/^\[[^\]]+\]\s*$/.test(lines[index].trim())) return index;
+  }
+  return lines.length;
+}
+
+/**
+ * Find a TOML table header line index.
+ *
+ * @param {string[]} lines - TOML content split by line.
+ * @param {number} start - Start index.
+ * @param {string} header - Exact table header text.
+ * @returns {number} Header index or -1 when missing.
+ */
+function findTomlHeader(lines, start, header) {
+  for (let index = start; index < lines.length; index += 1) {
+    if (lines[index].trim() === header) return index;
+  }
+  return -1;
+}
+
+/**
+ * Normalize `.codex/config.toml` loreli token forwarding.
+ *
+ * Ensures `env_vars = ["GITHUB_TOKEN"]` is defined in the
+ * `[mcp_servers.loreli]` table and not inside the nested
+ * `[mcp_servers.loreli.env]` table.
+ *
+ * @param {string} content - Existing TOML content.
+ * @returns {string|null} Updated content when changed, else null.
+ */
+function normalizeCodexEnvVars(content) {
+  if (/^\s*mcp_servers\.loreli\.env_vars\s*=.*$/m.test(content)) return null;
+
+  const lines = content.split('\n');
+  const loreli = findTomlHeader(lines, 0, '[mcp_servers.loreli]');
+  if (loreli === -1) return null;
+
+  let changed = false;
+  let env = findTomlHeader(lines, loreli + 1, '[mcp_servers.loreli.env]');
+
+  if (env !== -1) {
+    const envEnd = nextTomlTable(lines, env + 1);
+    const envLines = lines.slice(env + 1, envEnd);
+    const kept = envLines.filter(function keepLine(line) {
+      return !/^\s*env_vars\s*=/.test(line);
+    });
+    if (kept.length !== envLines.length) {
+      lines.splice(env + 1, envEnd - env - 1, ...kept);
+      changed = true;
+      env = findTomlHeader(lines, loreli + 1, '[mcp_servers.loreli.env]');
+    }
+  }
+
+  const loreliEnd = env === -1 ? nextTomlTable(lines, loreli + 1) : env;
+  const hasEnvVars = lines.slice(loreli + 1, loreliEnd).some(function hasLine(line) {
+    return /^\s*env_vars\s*=/.test(line);
+  });
+
+  if (!hasEnvVars) {
+    lines.splice(loreliEnd, 0, CODEX_ENV_VARS);
+    changed = true;
+  }
+
+  if (!changed) return null;
+  return lines.join('\n');
+}
+
 /**
  * Ensure the loreli MCP server is configured in all supported agent CLI
  * config files (.mcp.json, .cursor/mcp.json, .codex/config.toml).
@@ -665,6 +721,19 @@ async function ensureMcpConfigs(hub, repo, scaffolded, configs) {
 
     // File exists — check if loreli is already configured
     if (existing.content.includes(entry.marker)) {
+      if (entry.path === '.codex/config.toml') {
+        const updated = normalizeCodexEnvVars(existing.content);
+        if (updated) {
+          await hub.write(repo, entry.path, {
+            content: updated,
+            message: 'chore: add codex env_vars forwarding for loreli MCP server'
+          });
+          scaffolded.push(`${entry.path} (added env_vars forwarding)`);
+          log.info(`normalized env_vars forwarding in existing ${entry.path}`);
+          continue;
+        }
+      }
+
       log.info(`loreli already in ${entry.path} — skipping`);
       continue;
     }

package/packages/mcp/src/tools/status.js

@@ -1,5 +1,6 @@
-import { check } from 'loreli/config';
 import { has } from 'loreli/marker';
+import { select } from './repo.js';
+import { check } from 'loreli/config';
 
 export default {
   team_status: {
@@ -18,6 +19,8 @@ export default {
      * @returns {Promise<object>} Status dashboard.
      */
     async exec(args, ctx) {
+      // Validate repo format eagerly before any other guard so callers always
+      // get a thrown error on malformed input regardless of hub state.
       if (args.repo) check.repo(args.repo);
 
       // When the user explicitly requests a repo but hub is not initialized,
@@ -29,7 +32,7 @@ export default {
         return { content: [{ type: 'text', text: 'Run start first to initialize the hub.' }], isError: true };
       }
 
-      const repo = args.repo ?? ctx.repo;
+      const repo = select(args.repo, ctx);
       const lines = [`Team Status for ${repo ?? 'unknown repo'}`];
 
       // --- Agent States ---

package/packages/mcp/src/tools/work.js

@@ -1,5 +1,5 @@
 import { logger } from 'loreli/log';
-import { check } from 'loreli/config';
+import { select } from './repo.js';
 
 const log = logger('work');
 
@@ -21,7 +21,7 @@ export default {
         repo: { type: 'string', description: 'Target repository (owner/name).' },
         objective: { type: 'string', description: 'What should the planner analyze and plan for?' }
       },
-      required: ['repo', 'objective']
+      required: ['objective']
     },
 
     /**
@@ -30,8 +30,14 @@ export default {
      * @returns {Promise<object>} Planning initiation result.
      */
     async exec(args, ctx) {
-      check.repo(args.repo);
-      const { repo, objective } = args;
+      const repo = select(args.repo, ctx);
+      const objective = args.objective;
+      if (!repo) {
+        return {
+          content: [{ type: 'text', text: 'No repository configured. Pass --repo, run start, set LORELI_REPO, or set repo in loreli.yml.' }],
+          isError: true
+        };
+      }
 
       if (!ctx.hub) {
         return { content: [{ type: 'text', text: 'Run start first to initialize the hub.' }], isError: true };
@@ -72,8 +78,7 @@ export default {
       type: 'object',
       properties: {
         repo: { type: 'string', description: 'Target repository (owner/name).' }
-      },
-      required: ['repo']
+      }
     },
 
     /**
@@ -82,8 +87,13 @@ export default {
      * @returns {Promise<object>} Work cycle initiation result.
      */
     async exec(args, ctx) {
-      check.repo(args.repo);
-      const { repo } = args;
+      const repo = select(args.repo, ctx);
+      if (!repo) {
+        return {
+          content: [{ type: 'text', text: 'No repository configured. Pass --repo, run start, set LORELI_REPO, or set repo in loreli.yml.' }],
+          isError: true
+        };
+      }
 
       if (!ctx.hub) {
         return { content: [{ type: 'text', text: 'Run start first to initialize the hub.' }], isError: true };