@pellux/goodvibes-agent 1.5.2 → 1.5.3

package/src/tools/agent-harness-comms.ts

@@ -0,0 +1,378 @@
+import type { CommandContext } from '../input/command-registry.ts';
+import {
+  aggregateUnifiedInbox,
+  formatUnifiedInbox,
+} from '../agent/unified-inbox.ts';
+import {
+  listDrafts,
+  getDraft,
+  saveDraft,
+  queueDraftToSend,
+  markDraftSent,
+  markDraftFailed,
+  formatChannelDraftList,
+  formatChannelDraft,
+} from '../agent/channel-draft.ts';
+import {
+  listChannelProfileRoutes,
+  getProfileForChannel,
+  assignChannelToProfile,
+  removeChannelProfileRoute,
+  formatChannelProfileRoutes,
+} from '../agent/channel-profile-routing.ts';
+import { buildAgentWorkspaceChannelTriage } from '../input/agent-workspace-channel-triage.ts';
+import { deliverAgentChannelMessage } from '../agent/channel-delivery.ts';
+import { requireConfirmedAction } from './agent-harness-tool-utils.ts';
+
+/** Redact a draft's webhook (which can embed a token) in any structured display payload. */
+function redactDraftWebhook<T extends { readonly webhook?: string }>(draft: T): T {
+  return draft.webhook ? { ...draft, webhook: '[redacted]' } : draft;
+}
+
+export interface AgentHarnessCommsArgs {
+  readonly draftId?: unknown;
+  readonly draftStatus?: unknown;
+  readonly draftTitle?: unknown;
+  readonly draftMessage?: unknown;
+  readonly draftChannel?: unknown;
+  readonly draftRoute?: unknown;
+  readonly draftWebhook?: unknown;
+  readonly draftLink?: unknown;
+  readonly draftTags?: unknown;
+  readonly surfaceKind?: unknown;
+  readonly profileId?: unknown;
+  readonly routeLabel?: unknown;
+  readonly limit?: unknown;
+  readonly confirm?: unknown;
+  readonly explicitUserRequest?: unknown;
+  readonly target?: unknown;
+  readonly query?: unknown;
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readOptString(value: unknown): string | undefined {
+  const s = readString(value);
+  return s || undefined;
+}
+
+function readLimit(value: unknown, fallback: number): number {
+  const parsed = typeof value === 'string' && value.trim() ? Number(value) : value;
+  if (typeof parsed !== 'number' || !Number.isFinite(parsed)) return fallback;
+  return Math.max(1, Math.min(500, Math.trunc(parsed)));
+}
+
+function readStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  const arr = value.filter((v) => typeof v === 'string').map((v) => (v as string).trim()).filter(Boolean);
+  return arr.length > 0 ? arr : undefined;
+}
+
+// ---------------------------------------------------------------------------
+// INBOX — unified_inbox
+// ---------------------------------------------------------------------------
+
+export async function unifiedInboxSummary(
+  context: CommandContext,
+  args: AgentHarnessCommsArgs,
+): Promise<Record<string, unknown>> {
+  const triage = await buildAgentWorkspaceChannelTriage(context, {});
+  const limit = readLimit(args.limit, 50);
+  const inbox = aggregateUnifiedInbox(triage, { limit });
+  return {
+    mode: 'unified_inbox',
+    status: inbox.status,
+    summary: inbox.summary,
+    items: inbox.items,
+    sources: inbox.sources,
+    deliveryItems: inbox.deliveryItems,
+    surfaceMessageItems: inbox.surfaceMessageItems,
+    routeBindingItems: inbox.routeBindingItems,
+    inboundChannelFeed: inbox.inboundChannelFeed,
+    formatted: formatUnifiedInbox(inbox),
+    policy: inbox.policy,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// DRAFTS — channel_drafts (read)
+// ---------------------------------------------------------------------------
+
+export function channelDraftsSummary(
+  context: CommandContext,
+  args: AgentHarnessCommsArgs,
+): Record<string, unknown> {
+  const shellPaths = context.workspace?.shellPaths;
+  if (!shellPaths) {
+    return {
+      mode: 'channel_drafts',
+      status: 'unavailable',
+      drafts: [],
+      policy: 'Draft management requires an active Agent workspace with shell path context.',
+    };
+  }
+  const draftId = readOptString(args.draftId || args.target || args.query);
+  if (draftId) {
+    const draft = getDraft(shellPaths, draftId);
+    if (!draft) {
+      return {
+        mode: 'channel_drafts',
+        status: 'not_found',
+        draftId,
+        policy: 'Draft not found. Use channel_drafts without draftId to list all drafts.',
+      };
+    }
+    return {
+      mode: 'channel_drafts',
+      status: 'found',
+      draft: redactDraftWebhook(draft),
+      formatted: formatChannelDraft(draft),
+      routes: {
+        send: 'agent_harness mode:"channel_draft_send" draftId:"' + draft.id + '"',
+      },
+      policy: 'Read-only draft inspection. Use channel_draft_send to queue and deliver.',
+    };
+  }
+  const statusFilter = readOptString(args.draftStatus) as 'draft' | 'queued' | 'sent' | 'failed' | undefined;
+  const limit = readLimit(args.limit, 50);
+  const snapshot = listDrafts(shellPaths, { status: statusFilter, limit });
+  return {
+    mode: 'channel_drafts',
+    status: snapshot.exists ? 'ready' : 'empty',
+    path: snapshot.path,
+    total: snapshot.drafts.length,
+    drafts: snapshot.drafts.map(redactDraftWebhook),
+    formatted: formatChannelDraftList(snapshot),
+    routes: {
+      save: 'agent_harness mode:"channel_draft_save"',
+      send: 'agent_harness mode:"channel_draft_send" draftId:"<id>"',
+    },
+    ...(snapshot.parseError ? { parseError: snapshot.parseError } : {}),
+    policy: 'Read-only draft list. Drafts are local-only. Use channel_draft_save to create or update. Use channel_draft_send to deliver.',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// DRAFTS — channel_draft_save (effect)
+// ---------------------------------------------------------------------------
+
+export function channelDraftSaveHandoff(
+  context: CommandContext,
+  args: AgentHarnessCommsArgs,
+): Record<string, unknown> | string {
+  const confirmationError = requireConfirmedAction(args, 'Channel draft save');
+  if (confirmationError) return confirmationError;
+
+  const shellPaths = context.workspace?.shellPaths;
+  if (!shellPaths) return 'Channel draft save requires an active workspace.';
+
+  const message = readString(args.draftMessage);
+  if (!message) return 'channel_draft_save requires draftMessage.';
+
+  const result = saveDraft(shellPaths, {
+    id: readOptString(args.draftId),
+    message,
+    title: readOptString(args.draftTitle),
+    channel: readOptString(args.draftChannel),
+    route: readOptString(args.draftRoute),
+    webhook: readOptString(args.draftWebhook),
+    link: readOptString(args.draftLink),
+    tags: readStringArray(args.draftTags),
+  });
+
+  return {
+    mode: 'channel_draft_save',
+    draft: redactDraftWebhook(result.draft),
+    path: result.path,
+    routes: {
+      send: 'agent_harness mode:"channel_draft_send" draftId:"' + result.draft.id + '"',
+      list: 'agent_harness mode:"channel_drafts"',
+    },
+    policy: 'Draft saved locally. Use channel_draft_send with confirm:true and explicitUserRequest to deliver.',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// DRAFTS — channel_draft_send (effect)
+// ---------------------------------------------------------------------------
+
+export async function channelDraftSendHandoff(
+  context: CommandContext,
+  args: AgentHarnessCommsArgs,
+): Promise<Record<string, unknown> | string> {
+  const confirmationError = requireConfirmedAction(args, 'Channel draft send');
+  if (confirmationError) return confirmationError;
+
+  const shellPaths = context.workspace?.shellPaths;
+  if (!shellPaths) return 'Channel draft send requires an active workspace.';
+
+  const draftId = readString(args.draftId || args.target);
+  if (!draftId) return 'channel_draft_send requires draftId.';
+
+  const router = context.platform?.channelDeliveryRouter;
+  if (!router) {
+    return 'Channel delivery router is not available. Ensure the Agent is connected to a channel delivery service.';
+  }
+
+  let queueResult: ReturnType<typeof queueDraftToSend>;
+  try {
+    queueResult = queueDraftToSend(shellPaths, draftId);
+  } catch (err) {
+    return err instanceof Error ? err.message : String(err);
+  }
+
+  try {
+    const result = await deliverAgentChannelMessage(router, queueResult.deliveryInput);
+    const sentDraft = markDraftSent(shellPaths, draftId, result.responseId);
+    return {
+      mode: 'channel_draft_send',
+      status: 'sent',
+      draftId,
+      responseId: result.responseId ?? null,
+      draft: sentDraft ? redactDraftWebhook(sentDraft) : sentDraft,
+      delivery: {
+        message: result.message,
+        title: result.title,
+        target: result.target,
+        strategyCount: result.strategyCount,
+      },
+      policy: 'Draft delivered and marked sent. Receipt recorded via delivery path.',
+    };
+  } catch (err) {
+    const errorMessage = err instanceof Error ? err.message : String(err);
+    try {
+      markDraftFailed(shellPaths, draftId, errorMessage);
+    } catch {
+      // best-effort
+    }
+    return {
+      mode: 'channel_draft_send',
+      status: 'failed',
+      draftId,
+      error: errorMessage,
+      policy: 'Delivery failed. Draft marked failed. Retry with channel_draft_send or use agent_channel_send directly.',
+    };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// ROUTING — channel_routing (read)
+// ---------------------------------------------------------------------------
+
+export function channelRoutingSummary(
+  context: CommandContext,
+  args: AgentHarnessCommsArgs,
+): Record<string, unknown> {
+  const shellPaths = context.workspace?.shellPaths;
+  if (!shellPaths) {
+    return {
+      mode: 'channel_routing',
+      status: 'unavailable',
+      routes: [],
+      policy: 'Channel routing requires an active Agent workspace with shell path context.',
+    };
+  }
+  const surfaceKind = readOptString(args.surfaceKind || args.target || args.query);
+  if (surfaceKind) {
+    const profileId = getProfileForChannel(shellPaths, surfaceKind, readOptString(args.draftRoute));
+    const snapshot = listChannelProfileRoutes(shellPaths, { surfaceKind });
+    return {
+      mode: 'channel_routing',
+      status: snapshot.exists ? 'ready' : 'empty',
+      surfaceKind,
+      resolvedProfileId: profileId,
+      routes: snapshot.routes,
+      formatted: formatChannelProfileRoutes(snapshot),
+      policy: 'Read-only routing inspection. Use channel_routing_assign to add or update a profile assignment.',
+    };
+  }
+  const limit = readLimit(args.limit, 50);
+  const snapshot = listChannelProfileRoutes(shellPaths);
+  const limited = { ...snapshot, routes: snapshot.routes.slice(0, limit) };
+  return {
+    mode: 'channel_routing',
+    status: snapshot.exists ? 'ready' : 'empty',
+    path: snapshot.path,
+    total: snapshot.routes.length,
+    returned: limited.routes.length,
+    routes: limited.routes,
+    formatted: formatChannelProfileRoutes(limited),
+    assignRoute: 'agent_harness mode:"channel_routing_assign"',
+    removeRoute: 'agent_harness mode:"channel_routing_remove"',
+    ...(snapshot.parseError ? { parseError: snapshot.parseError } : {}),
+    policy: 'Read-only routing list. Assignments are local-only until daemon publishes channels.routing.assign.',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// ROUTING — channel_routing_assign (effect)
+// ---------------------------------------------------------------------------
+
+export function channelRoutingAssignHandoff(
+  context: CommandContext,
+  args: AgentHarnessCommsArgs,
+): Record<string, unknown> | string {
+  const confirmationError = requireConfirmedAction(args, 'Channel routing assignment');
+  if (confirmationError) return confirmationError;
+
+  const shellPaths = context.workspace?.shellPaths;
+  if (!shellPaths) return 'Channel routing assign requires an active workspace.';
+
+  const surfaceKind = readString(args.surfaceKind);
+  if (!surfaceKind) return 'channel_routing_assign requires surfaceKind.';
+  const profileId = readString(args.profileId);
+  if (!profileId) return 'channel_routing_assign requires profileId.';
+
+  const result = assignChannelToProfile(shellPaths, {
+    surfaceKind,
+    routeId: readOptString(args.draftRoute),
+    profileId,
+    label: readOptString(args.routeLabel),
+  });
+
+  return {
+    mode: 'channel_routing_assign',
+    created: result.created,
+    route: result.route,
+    path: result.path,
+    daemonMethodNeeded: result.route.daemonMethodNeeded,
+    routes: {
+      list: 'agent_harness mode:"channel_routing"',
+      remove: 'agent_harness mode:"channel_routing_remove" draftRoute:"' + (result.route.routeId ?? '') + '" surfaceKind:"' + surfaceKind + '"',
+    },
+    policy: 'Assignment saved locally (daemonSyncState: local_only). Daemon sync pending channels.routing.assign method publication.',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// ROUTING — channel_routing_remove (effect)
+// ---------------------------------------------------------------------------
+
+export function channelRoutingRemoveHandoff(
+  context: CommandContext,
+  args: AgentHarnessCommsArgs,
+): Record<string, unknown> | string {
+  const confirmationError = requireConfirmedAction(args, 'Channel routing removal');
+  if (confirmationError) return confirmationError;
+
+  const shellPaths = context.workspace?.shellPaths;
+  if (!shellPaths) return 'Channel routing remove requires an active workspace.';
+
+  const routeId = readString(args.draftRoute || args.target);
+  if (!routeId) return 'channel_routing_remove requires draftRoute (the route id to remove).';
+
+  const removed = removeChannelProfileRoute(shellPaths, routeId);
+  return {
+    mode: 'channel_routing_remove',
+    removed,
+    routeId,
+    routes: {
+      list: 'agent_harness mode:"channel_routing"',
+    },
+    policy: removed
+      ? 'Route removed locally. Daemon sync state is local_only until daemon contract is published.'
+      : 'No matching route found with that routeId.',
+  };
+}

package/src/tools/agent-harness-learning-auto-promote.ts

@@ -0,0 +1,288 @@
+import type { CommandContext } from '../input/command-registry.ts';
+import type { MemoryApi } from '@pellux/goodvibes-sdk/platform/knowledge';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { AgentPersonaRegistry } from '../agent/persona-registry.ts';
+import { AgentRoutineRegistry } from '../agent/routine-registry.ts';
+import { AgentSkillRegistry } from '../agent/skill-registry.ts';
+import { runSkillDraftProposer } from '../agent/skill-draft-runner.ts';
+import { buildLearningCandidates } from './agent-harness-learning-curator-proposals.ts';
+import type { LearningCandidate } from './agent-harness-learning-curator-types.ts';
+import {
+  deleteDuplicate,
+  domainForCandidate,
+  markDuplicateStale,
+  updateSurvivor,
+} from './agent-learning-consolidation-core.ts';
+import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+
+const AUTO_PROMOTE_PROVENANCE = 'learning-curator-auto-promote';
+
+// ---------------------------------------------------------------------------
+// Result type
+// ---------------------------------------------------------------------------
+
+export interface AutoPromoteResult {
+  /** Total candidates seen as ready-to-promote or needs-consolidation. */
+  readonly eligible: number;
+  /** Records successfully promoted this pass. */
+  readonly promoted: number;
+  /** Candidates skipped due to errors, missing data, or secret-scan rejection. */
+  readonly skipped: number;
+  /** Duplicate records consolidated (staled + deleted). */
+  readonly consolidated: number;
+  /** Per-domain breakdown. */
+  readonly domains: Record<string, number>;
+  /** Brief log lines for each promoted or consolidated item. */
+  readonly log: readonly string[];
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function extractProposalFields(
+  candidate: LearningCandidate,
+): Record<string, string> {
+  return candidate.proposalFields ?? {};
+}
+
+async function tryPromoteMemory(
+  memoryApi: MemoryApi,
+  candidate: LearningCandidate,
+): Promise<string> {
+  const fields = extractProposalFields(candidate);
+  const summary = (fields.summary ?? fields.detail ?? candidate.label).trim();
+  if (!summary) throw new Error('Missing summary for memory candidate.');
+  const detail = (fields.detail ?? '').trim();
+  const cls = (fields.cls ?? 'fact').trim() as Parameters<typeof memoryApi.add>[0]['cls'];
+  const scope = (fields.scope ?? 'project').trim() as Parameters<typeof memoryApi.add>[0]['scope'];
+  const tags = fields.tags
+    ? fields.tags.split(/[,;]+/).map((t) => t.trim()).filter(Boolean)
+    : [];
+  // assertNoSecretLikeText is called inside memoryApi.add
+  const record = await memoryApi.add({
+    scope,
+    cls,
+    summary,
+    detail,
+    tags,
+    provenance: [{ kind: 'event', ref: AUTO_PROMOTE_PROVENANCE }],
+  });
+  return `memory:${record.id}  ${summary.slice(0, 60)}`;
+}
+
+function tryPromotePersona(
+  shellPaths: ShellPathService,
+  candidate: LearningCandidate,
+): string {
+  const fields = extractProposalFields(candidate);
+  const name = (fields.name ?? candidate.label).trim();
+  if (!name) throw new Error('Missing name for persona candidate.');
+  const description = (fields.description ?? name).trim();
+  const body = (fields.body ?? fields.detail ?? '').trim();
+  if (!body) throw new Error('Missing body for persona candidate.');
+  const triggers = fields.triggers
+    ? fields.triggers.split(/[,;]+/).map((t) => t.trim()).filter(Boolean)
+    : [];
+  const tags = fields.tags
+    ? fields.tags.split(/[,;]+/).map((t) => t.trim()).filter(Boolean)
+    : [];
+  // assertNoSecretLikeText is called inside AgentPersonaRegistry.create
+  const record = AgentPersonaRegistry.fromShellPaths(shellPaths).create({
+    name,
+    description,
+    body,
+    triggers,
+    tags,
+    source: 'agent',
+    provenance: AUTO_PROMOTE_PROVENANCE,
+  });
+  return `persona:${record.id}  ${name.slice(0, 60)}`;
+}
+
+function tryPromoteRoutine(
+  shellPaths: ShellPathService,
+  candidate: LearningCandidate,
+): string {
+  const fields = extractProposalFields(candidate);
+  const name = (fields.name ?? candidate.label).trim();
+  if (!name) throw new Error('Missing name for routine candidate.');
+  const description = (fields.description ?? name).trim();
+  const steps = (fields.steps ?? fields.notes ?? fields.detail ?? '').trim();
+  if (!steps) throw new Error('Missing steps for routine candidate.');
+  const triggers = fields.triggers
+    ? fields.triggers.split(/[,;]+/).map((t) => t.trim()).filter(Boolean)
+    : [];
+  const tags = fields.tags
+    ? fields.tags.split(/[,;]+/).map((t) => t.trim()).filter(Boolean)
+    : [];
+  // assertNoSecretLikeText is called inside AgentRoutineRegistry.create
+  const record = AgentRoutineRegistry.fromShellPaths(shellPaths).create({
+    name,
+    description,
+    steps,
+    triggers,
+    tags,
+    enabled: true,
+    source: 'agent',
+    provenance: AUTO_PROMOTE_PROVENANCE,
+  });
+  return `routine:${record.id}  ${name.slice(0, 60)}`;
+}
+
+/**
+ * Consolidate a duplicate candidate for non-memory domains (persona/skill/routine).
+ * Memory domain consolidation is skipped here because it requires MemoryRegistry,
+ * which is not accessible from CommandContext (it is a service-level dependency).
+ */
+function tryConsolidateNonMemoryCandidate(
+  shellPaths: ShellPathService,
+  candidate: LearningCandidate,
+): readonly string[] {
+  const plan = candidate.consolidation;
+  if (!plan) throw new Error('No consolidation plan on candidate.');
+  const domain = domainForCandidate(candidate);
+
+  // Use a no-op MemoryRegistry sentinel — it is never called because domain
+  // is already checked above (domainForCandidate throws for non-consolidatable domains).
+  const nullMemory = null as unknown as MemoryRegistry;
+  const lines: string[] = [];
+
+  // Merge survivor fields when present
+  if (plan.updateFields) {
+    updateSurvivor(shellPaths, nullMemory, domain, plan.survivorId, plan.updateFields);
+    lines.push(`merged survivor ${domain}:${plan.survivorId}`);
+  }
+
+  // Mark duplicates stale then delete
+  for (const dupId of plan.duplicateIds) {
+    try {
+      markDuplicateStale(shellPaths, nullMemory, domain, dupId, plan.survivorId);
+      deleteDuplicate(shellPaths, nullMemory, domain, dupId);
+      lines.push(`consolidated duplicate ${domain}:${dupId} -> ${plan.survivorId}`);
+    } catch (err) {
+      lines.push(`skipped duplicate ${domain}:${dupId}: ${String(err)}`);
+    }
+  }
+
+  return lines;
+}
+
+// ---------------------------------------------------------------------------
+// Main executor
+// ---------------------------------------------------------------------------
+
+/**
+ * Run the autonomous promotion pass. Promotes `ready-to-promote` candidates
+ * and resolves `needs-consolidation` duplicates (non-memory domains) without
+ * requiring confirm:true / explicitUserRequest.
+ *
+ * Secret scanning is enforced by each registry's create() method — this
+ * function does NOT bypass it.
+ *
+ * Memory domain consolidation is intentionally skipped: MemoryRegistry is a
+ * service-level dependency not available in CommandContext. Memory promotions
+ * (new records from proposal candidates) ARE supported via MemoryApi.
+ */
+export async function runAutoPromoter(
+  context: CommandContext,
+  skillRegistry: AgentSkillRegistry,
+  memoryApi: MemoryApi,
+): Promise<AutoPromoteResult> {
+  const shellPaths = context.workspace?.shellPaths;
+  if (!shellPaths) {
+    return {
+      eligible: 0,
+      promoted: 0,
+      skipped: 0,
+      consolidated: 0,
+      domains: {},
+      log: ['No active workspace; promotion skipped.'],
+    };
+  }
+
+  const all = buildLearningCandidates(context);
+  const promotionCandidates = all.filter((c) => c.status === 'ready-to-promote');
+  // Only consolidate non-memory domains (MemoryRegistry not available here)
+  const consolidationCandidates = all.filter(
+    (c) => c.status === 'needs-consolidation' && c.consolidation !== undefined && c.domain !== 'memory',
+  );
+  const eligible = promotionCandidates.length + consolidationCandidates.length;
+
+  const log: string[] = [];
+  const domains: Record<string, number> = {};
+  let promoted = 0;
+  let skipped = 0;
+  let consolidated = 0;
+
+  function bump(domain: string): void {
+    domains[domain] = (domains[domain] ?? 0) + 1;
+  }
+
+  // --- Skill promotions via runSkillDraftProposer (handles dedup + ledger) ---
+  const skillResult = runSkillDraftProposer(context, skillRegistry);
+  if (skillResult.proposed > 0) {
+    for (const entry of skillResult.entries) {
+      log.push(`promoted skill:${entry.skillId}  ${entry.name}`);
+      bump('skill');
+    }
+    promoted += skillResult.proposed;
+  }
+  skipped += skillResult.skipped;
+
+  // --- Non-skill ready-to-promote candidates ---
+  for (const candidate of promotionCandidates) {
+    if (candidate.proposalTarget === 'skill') continue; // handled above
+
+    try {
+      let line: string;
+      switch (candidate.proposalTarget) {
+        case 'memory': {
+          line = await tryPromoteMemory(memoryApi, candidate);
+          promoted += 1;
+          bump('memory');
+          break;
+        }
+        case 'persona': {
+          line = tryPromotePersona(shellPaths, candidate);
+          promoted += 1;
+          bump('persona');
+          break;
+        }
+        case 'routine': {
+          line = tryPromoteRoutine(shellPaths, candidate);
+          promoted += 1;
+          bump('routine');
+          break;
+        }
+        default: {
+          // No create path for this target (e.g. notes-to-knowledge is a
+          // workspace action that requires a browser session — skip it).
+          skipped += 1;
+          continue;
+        }
+      }
+      log.push(`promoted ${line}`);
+    } catch (err) {
+      log.push(`skipped ${candidate.label}: ${String(err)}`);
+      skipped += 1;
+    }
+  }
+
+  // --- Non-memory consolidation candidates ---
+  for (const candidate of consolidationCandidates) {
+    try {
+      const lines = tryConsolidateNonMemoryCandidate(shellPaths, candidate);
+      const dupeCount = candidate.consolidation?.duplicateIds.length ?? 0;
+      consolidated += dupeCount;
+      promoted += dupeCount;
+      bump(candidate.domain);
+      log.push(...lines);
+    } catch (err) {
+      log.push(`skipped ${candidate.label}: ${String(err)}`);
+      skipped += 1;
+    }
+  }
+
+  return { eligible, promoted, skipped, consolidated, domains, log };
+}