loreli 1.0.0 → 2.0.0

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

@@ -88,7 +88,10 @@ export default {
       }
 
       const { role } = args;
-      const modelAlias = args.model ?? ctx.config?.get?.('model') ?? 'balanced';
+      const modelAlias = args.model
+        ?? ctx.config?.get?.(`workflows.${role}.model`)
+        ?? ctx.config?.get?.('model')
+        ?? 'balanced';
 
       // Theme coherence: explicit override > peer inheritance > random pick from config.
       // When multiple themes are configured, the first agent picks randomly
@@ -111,7 +114,7 @@ export default {
       // Resolve model alias to concrete identifier via backend-specific config.
       // Virtual providers (cursor-openai, cursor-anthropic) normalize to the
       // canonical vendor for config lookup (backends.cursor.models.balanced.openai).
-      const model = models.resolve(modelAlias, backendName, vendor(provider), ctx.config);
+      const model = models.resolve(modelAlias, backendName, vendor(provider), ctx.config, ctx.backendRegistry?.models);
       log.info(`add_agent: provider=${provider} role=${role} model=${model} backend=${backendName} theme=${theme}`);
 
       // Seed taken names before first acquire — one-time cost, zero
@@ -358,25 +361,26 @@ export default {
   stop: {
     title: 'Stop Agent',
     description: [
-      'Stop an agent by name. Use "shutdown" for graceful termination (agent finishes',
-      'current work, then cleans up) or "kill" for immediate forced termination of a',
-      'stuck or misbehaving agent. Graceful shutdown escalates to kill after timeout.',
+      'Stop agents or halt the entire system. Three escalation levels:',
       '',
       'Actions:',
-      '- "shutdown": Graceful stop. Agent completes current task, responds, then exits.',
-      '- "kill": Immediate forced termination. Kills tmux pane, cleans up session. Last resort.'
+      '- "shutdown": Graceful stop of a single agent by name. Agent completes current task, then exits.',
+      '- "kill": Immediate forced termination of a single agent by name. Last resort.',
+      '- "halt": Full system stop. Kills the reactor loop, stall monitor, and all agents.',
+      '  The MCP server stays alive so `start` can resume the system. Use when you need',
+      '  everything to stop and stay stopped. The "name" parameter is ignored for halt.'
     ].join('\n'),
     schema: {
       type: 'object',
       properties: {
         action: {
           type: 'string',
-          description: 'Operation: "shutdown" or "kill".',
-          enum: ['shutdown', 'kill']
+          description: 'Operation: "shutdown", "kill", or "halt".',
+          enum: ['shutdown', 'kill', 'halt']
         },
-        name: { type: 'string', description: 'Agent identity name to stop.' }
+        name: { type: 'string', description: 'Agent identity name to stop (not required for "halt").' }
       },
-      required: ['action', 'name']
+      required: ['action']
     },
 
     /**
@@ -387,13 +391,30 @@ export default {
     async exec(args, ctx) {
       const { action, name } = args;
 
-      if (action !== 'shutdown' && action !== 'kill') {
+      if (action !== 'shutdown' && action !== 'kill' && action !== 'halt') {
         return {
-          content: [{ type: 'text', text: `Unknown action: "${action}". Valid: shutdown, kill` }],
+          content: [{ type: 'text', text: `Unknown action: "${action}". Valid: shutdown, kill, halt` }],
           isError: true
         };
       }
 
+      if (action === 'halt') {
+        try {
+          const result = await ctx.orchestrator.halt();
+          const parts = [`System halted.`];
+          if (result.reactor) parts.push('Reactor loop stopped.');
+          if (result.monitor) parts.push('Stall monitor stopped.');
+          if (result.agents.length) {
+            parts.push(`Killed ${result.agents.length} agent(s): ${result.agents.join(', ')}.`);
+          } else {
+            parts.push('No agents were running.');
+          }
+          return { content: [{ type: 'text', text: parts.join(' ') }] };
+        } catch (err) {
+          return { content: [{ type: 'text', text: err.message }], isError: true };
+        }
+      }
+
       check.name(name);
 
       if (ctx.orchestrator?.reconcile) await ctx.orchestrator.reconcile();

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

@@ -15,6 +15,7 @@ import { hub as createHub } from 'loreli/hub';
 import { blame, history, search, resolve } from 'loreli/context';
 import * as workspace from 'loreli/workspace';
 import { logger } from 'loreli/log';
+import { repoOf } from './repo.js';
 
 const log = logger('context');
 
@@ -56,10 +57,10 @@ export default {
         }
       }
 
-      const repo = ctx.repo;
+      const repo = repoOf(ctx);
       if (!repo) {
         return {
-          content: [{ type: 'text', text: 'No repository configured. Run start first or set LORELI_REPO.' }],
+          content: [{ type: 'text', text: 'No repository configured. Pass --repo, run start, set LORELI_REPO, or set repo in loreli.yml.' }],
           isError: true
         };
       }

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

@@ -3,6 +3,7 @@ import { commitAndPush, pathFor } from 'loreli/workspace';
 import { logger } from 'loreli/log';
 import { mark, excise, has, parse } from 'loreli/marker';
 import { trace, output } from 'loreli/agent';
+import { context } from './agent-context.js';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 
@@ -67,51 +68,6 @@ const EVENT_LABEL_INVERSE = {
   REQUEST_CHANGES: 'loreli:approved'
 };
 
-/**
- * Resolve agent context from session storage.
- *
- * Reads the agent's persisted session data using the sessionId and
- * agentName from ctx (hydrated at MCP server startup from env vars).
- * Reconstructs a live Identity instance so hub stamping and label
- * methods work correctly. Throws when context is not available — this
- * means the tool was called from a non-agent MCP client.
- *
- * @param {object} ctx - Execution context with sessionId, agentName, storage.
- * @returns {Promise<{repo: string, identity: Identity, role: string, task: object|null, issue: number|null}>}
- * @throws {Error} When agent context is not available.
- */
-async function context(ctx) {
-  if (!ctx.sessionId || !ctx.agentName) {
-    throw new Error('Agent context not available. This tool can only be called by spawned agents.');
-  }
-
-  const data = await ctx.storage.load(ctx.sessionId, ctx.agentName);
-  if (!data) {
-    throw new Error(`Session data not found for agent "${ctx.agentName}" in session "${ctx.sessionId}".`);
-  }
-
-  // Reconstruct a live Identity from stored JSON — constructor expects
-  // `name` as the character name (without instance suffix), while toJSON
-  // stores `name` as the full name and `character` as the raw character.
-  const raw = data.identity;
-  const identity = new Identity({
-    name: raw.character ?? raw.name,
-    instance: raw.instance ?? 0,
-    faction: raw.faction,
-    provider: raw.provider,
-    model: raw.model,
-    theme: raw.theme
-  });
-
-  return {
-    repo: data.repo,
-    identity,
-    role: data.role,
-    task: data.task ?? null,
-    issue: data.claimedIssue ?? data.task?.issue ?? null,
-    paneId: data.paneId ?? null
-  };
-}
 
 /**
  * Capture tmux pane output and build a trace block for the given agent.
@@ -429,7 +385,12 @@ export default {
 
         const cat = await ctx.hub.category(agent.repo, 'Loreli');
         const scoped = ctx.hub.as(agent.identity, agent.role);
-        const labels = agent.identity.labels?.(agent.role) ?? ['loreli'];
+        const labels = [...(agent.identity.labels?.(agent.role) ?? ['loreli'])];
+
+        const feedbackData = parse(args.body, 'feedback');
+        if (feedbackData?.category) {
+          labels.push(`loreli:feedback:${feedbackData.category}`);
+        }
 
         let body = args.body;
         const traceBlock = await captureTrace(agent, { reasoning: args.reasoning, prefix: 'plan/create' });
@@ -524,7 +485,10 @@ export default {
         if (args.decision === 'changes-requested') {
           try {
             const { classify } = await import('loreli/knowledge');
-            const { category, confidence } = classify(args.comment);
+            const { category, confidence } = await classify(args.comment, {
+              backends: ctx.backendRegistry ?? ctx.orchestrator?.backendRegistry,
+              config: ctx.config ?? ctx.orchestrator?.cfg
+            });
             if (confidence > 0) {
               const provider = agent.identity?.provider ?? 'unknown';
               feedbackTag = mark('feedback', {

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

@@ -1,6 +1,7 @@
 import { logger } from 'loreli/log';
 import { check } from 'loreli/config';
 import { has, parse } from 'loreli/marker';
+import { select } from './repo.js';
 
 const log = logger('hitl');
 
@@ -20,7 +21,7 @@ export default {
         repo: { type: 'string', description: 'Target repository (owner/name).' },
         pr: { type: 'number', description: 'Pull request number.' }
       },
-      required: ['repo', 'pr']
+      required: ['pr']
     },
     /**
      * @param {object} args - Tool arguments.
@@ -28,9 +29,15 @@ export default {
      * @returns {Promise<object>} HITL result with reviewer list.
      */
     async exec(args, ctx) {
-      check.repo(args.repo);
       check.positive(args.pr, 'PR number');
-      const { repo, pr } = args;
+      const repo = select(args.repo, ctx);
+      const pr = args.pr;
+      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
+        };
+      }
       const reviewers = ctx.config?.get?.('reviewers') ?? [];
 
       if (!reviewers.length) {
@@ -87,7 +94,7 @@ export default {
         pr: { type: 'number', description: 'Pull request number.' },
         since: { type: 'string', description: 'ISO timestamp to filter comments after (hitlAt).' }
       },
-      required: ['repo', 'pr', 'since']
+      required: ['pr', 'since']
     },
     /**
      * @param {object} args - Tool arguments.
@@ -95,9 +102,15 @@ export default {
      * @returns {Promise<object>} Watch result with status and optional feedback.
      */
     async exec(args, ctx) {
-      check.repo(args.repo);
       check.positive(args.pr, 'PR number');
-      const { repo, pr, since } = args;
+      const repo = select(args.repo, ctx);
+      const { pr, since } = args;
+      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
+        };
+      }
 
       // Inline: pending() was a 3-line hub method — timestamp filter on comments()
       const allComments = await ctx.hub.comments(repo, pr);

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

@@ -5,6 +5,7 @@ import status from './status.js';
 import hitl from './hitl.js';
 import github from './github.js';
 import context from './context.js';
+import refactor from './refactor.js';
 
 /**
  * All tool definitions aggregated from individual modules.
@@ -12,6 +13,6 @@ import context from './context.js';
  * @returns {Record<string, object>} Map of tool name to tool definition.
  */
 export function allTools() {
-  return { ...start, ...agents, ...work, ...status, ...hitl, ...github, ...context };
+  return { ...start, ...agents, ...work, ...status, ...hitl, ...github, ...context, ...refactor };
 }
 

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

@@ -0,0 +1,227 @@
+import { context } from './agent-context.js';
+import { logger } from 'loreli/log';
+
+const log = logger('refactor-tool');
+
+/**
+ * Valid observation categories.
+ *
+ * @type {Set<string>}
+ */
+const KINDS = new Set(['bug', 'refactor', 'smell', 'debt']);
+
+/**
+ * Valid impact levels.
+ *
+ * @type {Set<string>}
+ */
+const IMPACTS = new Set(['low', 'medium', 'high']);
+
+/**
+ * Validates file path entries against the allowed formats:
+ * plain path or path with GitHub-style line range hint.
+ *
+ * @type {RegExp}
+ */
+const FILE_PATTERN = /^[^\s#]+(?:#R\d+-R\d+)?$/;
+
+/**
+ * Check whether a normalized title appears in an existing item's title.
+ *
+ * @param {string} needle - Normalized title to search for.
+ * @param {string} haystack - Item title to compare against.
+ * @returns {boolean} True when considered a match.
+ */
+function titleMatch(needle, haystack) {
+  return haystack.toLowerCase().includes(needle);
+}
+
+/**
+ * Build a structured discussion body from the refactor observation.
+ *
+ * @param {object} agent - Resolved agent context.
+ * @param {object} args - Tool arguments.
+ * @returns {string} Formatted Markdown body.
+ */
+function body(agent, args) {
+  const lines = [
+    `## ${args.kind}: ${args.title}`,
+    '',
+    args.description,
+    '',
+    `**Kind**: ${args.kind}`,
+    `**Impact**: ${args.impact ?? 'medium'}`,
+    `**Reported by**: ${agent.identity.name} (${agent.role})`,
+  ];
+
+  if (agent.issue) lines.push(`**Source issue**: #${agent.issue}`);
+
+  if (args.files?.length) {
+    lines.push('', '### Affected files', '');
+    for (const f of args.files) lines.push(`- \`${f}\``);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Refactor tool — opportunistic improvement intake for action agents.
+ *
+ * Creates a labeled discussion in the Loreli category after dedup
+ * checks. Existing planner review/revise/promote handles the rest.
+ */
+export default {
+  refactor: {
+    title: 'Refactor',
+    description: [
+      'Flag a bug, code smell, or tech debt you encounter during implementation.',
+      'Call immediately on discovery — do not wait until your PR is complete.',
+      'Provide kind, title, and description with stable identifiers (function names, class names, patterns).',
+      'Optionally include affected files (with optional #R<start>-R<end> range hints) and impact level.',
+      'The tool checks for duplicates and creates a Loreli discussion for planning. Action agents only.'
+    ].join(' '),
+    schema: {
+      type: 'object',
+      properties: {
+        kind: {
+          type: 'string',
+          description: 'Category of observation.',
+          enum: ['bug', 'refactor', 'smell', 'debt']
+        },
+        title: {
+          type: 'string',
+          description: 'Concise improvement title.'
+        },
+        description: {
+          type: 'string',
+          description: 'Problem statement with stable identifiers (function names, class names, error messages). Not line numbers.'
+        },
+        files: {
+          type: 'array',
+          items: { type: 'string' },
+          description: 'Affected file paths. Optionally append #R<start>-R<end> for line range hints, e.g. "src/hub.js#R40-R50".'
+        },
+        impact: {
+          type: 'string',
+          description: 'Estimated impact: low, medium, or high. Defaults to medium.',
+          enum: ['low', 'medium', 'high']
+        }
+      },
+      required: ['kind', 'title', 'description']
+    },
+
+    /**
+     * @param {object} args - Tool arguments.
+     * @param {object} ctx - Execution context.
+     * @returns {Promise<object>} MCP tool result.
+     */
+    async exec(args, ctx) {
+      if (!KINDS.has(args.kind)) {
+        return {
+          content: [{ type: 'text', text: `Invalid kind: "${args.kind}". Valid: ${[...KINDS].join(', ')}` }],
+          isError: true
+        };
+      }
+
+      if (!args.title?.trim()) {
+        return { content: [{ type: 'text', text: 'title is required.' }], isError: true };
+      }
+
+      if (!args.description?.trim()) {
+        return { content: [{ type: 'text', text: 'description is required.' }], isError: true };
+      }
+
+      if (args.impact && !IMPACTS.has(args.impact)) {
+        return {
+          content: [{ type: 'text', text: `Invalid impact: "${args.impact}". Valid: ${[...IMPACTS].join(', ')}` }],
+          isError: true
+        };
+      }
+
+      if (args.files?.length) {
+        for (const f of args.files) {
+          if (!FILE_PATTERN.test(f)) {
+            return {
+              content: [{ type: 'text', text: `Invalid file entry: "${f}". Use "<path>" or "<path>#R<start>-R<end>".` }],
+              isError: true
+            };
+          }
+        }
+      }
+
+      if (!ctx.hub) {
+        return { content: [{ type: 'text', text: 'Hub not initialized. Run start first.' }], isError: true };
+      }
+
+      let agent;
+      try {
+        agent = await context(ctx);
+      } catch (err) {
+        return { content: [{ type: 'text', text: err.message }], isError: true };
+      }
+
+      if (agent.role !== 'action') {
+        return {
+          content: [{ type: 'text', text: 'refactor is restricted to action agents.' }],
+          isError: true
+        };
+      }
+
+      // ── Dedup gate ────────────────────────────────────────
+      const normalized = args.title.trim().toLowerCase();
+      const cat = await ctx.hub.category(agent.repo, 'Loreli');
+
+      // 1. Search existing issues and PRs
+      try {
+        const existing = await ctx.hub.searchIssues(agent.repo, args.title);
+        const match = existing.find(function dup(i) { return titleMatch(normalized, i.title); });
+        if (match) {
+          log.info(`refactor: dedup hit via issue search — #${match.number}: ${match.title}`);
+          return {
+            content: [{ type: 'text', text: `Already tracked at #${match.number} (${match.url}). Skipping.` }]
+          };
+        }
+      } catch (err) {
+        log.debug(`refactor: issue search failed, proceeding: ${err.message}`);
+      }
+
+      // 2. Scan open Loreli discussions with loreli:refactor label
+      try {
+        const discussions = await ctx.hub.discussions(agent.repo, cat.id);
+        const match = discussions.find(function dup(d) {
+          return !d.closed &&
+            d.labels.includes('loreli:refactor') &&
+            titleMatch(normalized, d.title);
+        });
+        if (match) {
+          log.info(`refactor: dedup hit via discussion scan — #${match.number}: ${match.title}`);
+          return {
+            content: [{ type: 'text', text: `Already tracked at discussion #${match.number} (${match.url}). Skipping.` }]
+          };
+        }
+      } catch (err) {
+        log.debug(`refactor: discussion scan failed, proceeding: ${err.message}`);
+      }
+
+      // ── Create discussion ─────────────────────────────────
+      const scoped = ctx.hub.as(agent.identity, agent.role);
+      const labels = [...(agent.identity.labels?.(agent.role) ?? ['loreli']), 'loreli:refactor'];
+
+      const disc = await scoped.discuss(agent.repo, {
+        title: `[${args.kind}] ${args.title}`,
+        body: body(agent, args),
+        categoryId: cat.id,
+        repositoryId: cat.repositoryId,
+        labels
+      });
+
+      log.info(`refactor: created discussion #${disc.number} — [${args.kind}] ${args.title}`);
+      return {
+        content: [{
+          type: 'text',
+          text: `Refactor flagged as discussion #${disc.number}: [${args.kind}] ${args.title}\nURL: ${disc.url}`
+        }]
+      };
+    }
+  }
+};

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

@@ -0,0 +1,44 @@
+import { check } from 'loreli/config';
+
+/**
+ * Resolve repository context from the shared execution context.
+ *
+ * Priority order:
+ * 1. Runtime `ctx.repo` (set by start/session hydration)
+ * 2. Config fallback (`repo` key from loreli.yml or env)
+ *
+ * @param {object} ctx - Tool execution context.
+ * @returns {string|null} Repository slug (`owner/name`) or null.
+ */
+export function repoOf(ctx) {
+  if (ctx?.repo) return ctx.repo;
+
+  const repo = ctx?.config?.get?.('repo') ?? null;
+  if (!repo) return null;
+
+  // Validate env/config fallback immediately so tool errors are explicit.
+  check.repo(repo);
+  if (ctx && typeof ctx === 'object') ctx.repo = repo;
+  return repo;
+}
+
+/**
+ * Resolve a repository from tool arguments with shared fallback behavior.
+ *
+ * Priority order:
+ * 1. Explicit `--repo` argument
+ * 2. `repoOf(ctx)` fallback
+ *
+ * @param {string|undefined} arg - Explicit repo argument from tool input.
+ * @param {object} ctx - Tool execution context.
+ * @returns {string|null} Repository slug (`owner/name`) or null.
+ */
+export function select(arg, ctx) {
+  if (arg) {
+    check.repo(arg);
+    if (ctx && typeof ctx === 'object') ctx.repo = arg;
+    return arg;
+  }
+
+  return repoOf(ctx);
+}