@soleri/core 9.0.4 → 9.2.0

package/src/runtime/orchestrate-ops.ts

@@ -17,6 +17,24 @@ import { FlowExecutor } from '../flows/executor.js';
 import { createDispatcher } from '../flows/dispatch-registry.js';
 import { runEpilogue } from '../flows/epilogue.js';
 import type { OrchestrationPlan, ExecutionResult } from '../flows/types.js';
+import type { ContextHealthStatus } from './context-health.js';
+import {
+  detectGitHubContext,
+  findMatchingMilestone,
+  findDuplicateIssue,
+  formatIssueBody,
+  createGitHubIssue,
+  updateGitHubIssueBody,
+} from '../planning/github-projection.js';
+import type { PlanMetadataForIssue, GitHubProjection } from '../planning/github-projection.js';
+import {
+  extractIssueNumber,
+  detectGitHubRemote as detectGitHubRemoteAsync,
+  getIssueDetails,
+} from './github-integration.js';
+import { detectRationalizations } from '../planning/rationalization-detector.js';
+import { ImpactAnalyzer } from '../planning/impact-analyzer.js';
+import type { ImpactReport } from '../planning/impact-analyzer.js';
 
 // ---------------------------------------------------------------------------
 // Intent detection — keyword-based mapping from prompt to intent
@@ -61,11 +79,7 @@ const planStore = new Map<string, PlanEntry>();
  * If facades are provided, uses the full dispatch registry.
  * Otherwise, falls back to a simple runtime-based dispatcher.
  */
-function buildDispatch(
-  agentId: string,
-  runtime: AgentRuntime,
-  facades?: FacadeConfig[],
-) {
+function buildDispatch(agentId: string, runtime: AgentRuntime, facades?: FacadeConfig[]) {
   if (facades && facades.length > 0) {
     return createDispatcher(agentId, facades);
   }
@@ -110,6 +124,104 @@ function buildDispatch(
   };
 }
 
+// ---------------------------------------------------------------------------
+// Context health warning builder
+// ---------------------------------------------------------------------------
+
+interface HealthWarning {
+  level: string;
+  recommendation: string;
+  sessionCaptured?: boolean;
+}
+
+/**
+ * Build a context health warning if level is yellow or red.
+ * On red: auto-triggers a session capture to vault memory.
+ */
+function buildHealthWarning(
+  status: ContextHealthStatus,
+  vault: AgentRuntime['vault'],
+): HealthWarning | null {
+  if (status.level === 'green') return null;
+
+  const warning: HealthWarning = {
+    level: status.level,
+    recommendation: status.recommendation,
+  };
+
+  if (status.level === 'red') {
+    try {
+      vault.captureMemory({
+        projectPath: '.',
+        type: 'session',
+        context: 'Auto-captured by context health monitor (red level)',
+        summary: `Context fill at ${(status.estimatedFill * 100).toFixed(0)}% (${status.toolCallCount} tool calls, ~${status.estimatedTokens} tokens). Session capture recommended.`,
+        topics: ['context-health'],
+        filesModified: [],
+        toolsUsed: [],
+        intent: null,
+        decisions: [],
+        currentState: `Context health: ${status.level}`,
+        nextSteps: ['Compact context or start a new session'],
+        vaultEntriesReferenced: [],
+      });
+      warning.sessionCaptured = true;
+    } catch {
+      warning.sessionCaptured = false;
+    }
+  }
+
+  return warning;
+}
+
+// ---------------------------------------------------------------------------
+// Anti-rationalization helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Collect all acceptance criteria from a plan's tasks.
+ * Returns empty array if plan not found or has no criteria (graceful skip).
+ */
+function collectAcceptanceCriteria(
+  plannerRef: AgentRuntime['planner'],
+  planId: string,
+): string[] {
+  const plan = plannerRef.get(planId);
+  if (!plan) return [];
+  const criteria: string[] = [];
+  for (const task of plan.tasks) {
+    if (task.acceptanceCriteria) {
+      criteria.push(...task.acceptanceCriteria);
+    }
+  }
+  return criteria;
+}
+
+/**
+ * Capture detected rationalization as an anti-pattern in vault.
+ * Best-effort — never throws.
+ */
+function captureRationalizationAntiPattern(
+  vaultRef: AgentRuntime['vault'],
+  report: import('../planning/rationalization-detector.js').RationalizationReport,
+): void {
+  try {
+    const patterns = report.items.map((i) => i.pattern).join(', ');
+    vaultRef.add({
+      id: `antipattern-rationalization-${Date.now()}`,
+      title: 'Rationalization detected in completion claim',
+      description: `Detected rationalization patterns: ${patterns}. ` +
+        `Items: ${report.items.map((i) => `"${i.phrase}" (${i.pattern})`).join('; ')}.`,
+      type: 'anti-pattern',
+      domain: 'planning',
+      severity: 'warning',
+      tags: ['rationalization', 'anti-pattern', 'completion-gate'],
+    });
+  } catch {
+    // Vault capture is best-effort
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Op factory
 // ---------------------------------------------------------------------------
@@ -122,7 +234,7 @@ export function createOrchestrateOps(
   runtime: AgentRuntime,
   facades?: FacadeConfig[],
 ): OpDefinition[] {
-  const { planner, brainIntelligence, vault } = runtime;
+  const { planner, brainIntelligence, vault, contextHealth } = runtime;
   const agentId = runtime.config.agentId;
 
   return [
@@ -135,27 +247,12 @@ export function createOrchestrateOps(
         'a pruned orchestration plan with gate-guarded steps.',
       auth: 'write',
       schema: z.object({
-        prompt: z
-          .string()
-          .describe('Natural language description of what to do'),
-        projectPath: z
-          .string()
-          .optional()
-          .default('.')
-          .describe('Project root path'),
+        prompt: z.string().optional().describe('Natural language description of what to do (or use objective)'),
+        projectPath: z.string().optional().default('.').describe('Project root path'),
         // Legacy params — still accepted for backward compat
-        objective: z
-          .string()
-          .optional()
-          .describe('(Legacy) Plan objective — use prompt instead'),
-        scope: z
-          .string()
-          .optional()
-          .describe('(Legacy) Plan scope'),
-        domain: z
-          .string()
-          .optional()
-          .describe('Domain hint for brain recommendations'),
+        objective: z.string().optional().describe('(Legacy) Plan objective — use prompt instead'),
+        scope: z.string().optional().describe('(Legacy) Plan scope'),
+        domain: z.string().optional().describe('Domain hint for brain recommendations'),
         tasks: z
           .array(z.object({ title: z.string(), description: z.string() }))
           .optional()
@@ -170,17 +267,21 @@ export function createOrchestrateOps(
         const intent = detectIntent(prompt);
 
         // 2. Get brain recommendations — graceful degradation
-        let recommendations: Array<{ pattern: string; strength: number }> = [];
+        let recommendations: Array<{ pattern: string; strength: number; entryId?: string }> = [];
         try {
           const raw = brainIntelligence.recommend({
             domain,
             task: prompt,
             limit: 5,
           });
-          recommendations = raw.map((r) => ({
-            pattern: r.pattern,
-            strength: r.strength,
-          }));
+          recommendations = raw.map((r) => {
+            // Look up vault entry ID by title for feedback tracking
+            const entries = vault.search(r.pattern, { limit: 1 });
+            const entryId = entries.length > 0 && entries[0].entry.title === r.pattern
+              ? entries[0].entry.id
+              : undefined;
+            return { pattern: r.pattern, strength: r.strength, entryId };
+          });
         } catch {
           // Brain has no data yet
         }
@@ -192,6 +293,7 @@ export function createOrchestrateOps(
             recommendations = vaultResults.map((r) => ({
               pattern: r.entry.title,
               strength: 50,
+              entryId: r.entry.id,
             }));
           } catch {
             // Vault search failed
@@ -206,18 +308,44 @@ export function createOrchestrateOps(
 
         // 5. Also create a planner plan for lifecycle tracking (backward compat)
         const decisions = recommendations.map(
-          (r) => `Brain pattern: ${r.pattern} (strength: ${r.strength.toFixed(1)})`,
+          (r) => {
+            const base = `Brain pattern: ${r.pattern} (strength: ${r.strength.toFixed(1)})`;
+            return r.entryId ? `${base} [entryId:${r.entryId}]` : base;
+          },
         );
         const tasks = (params.tasks as Array<{ title: string; description: string }>) ?? [];
 
+        // 5b. Extract GitHub issue context if prompt references #NNN
+        let githubIssue: { owner: string; repo: string; number: number } | undefined;
+        const issueNum = extractIssueNumber(prompt);
+        if (issueNum) {
+          const remote = await detectGitHubRemoteAsync(projectPath);
+          if (remote) {
+            githubIssue = { owner: remote.owner, repo: remote.repo, number: issueNum };
+            const details = await getIssueDetails(remote.owner, remote.repo, issueNum);
+            if (details) {
+              // Enrich objective with issue context
+              const enriched = `${prompt}\n\n--- GitHub Issue #${issueNum}: ${details.title} ---\n${details.body}`;
+              decisions.unshift(`Source: GitHub issue #${issueNum} — ${details.title}`);
+              // Replace prompt for plan creation
+              Object.assign(params, { _enrichedObjective: enriched });
+            }
+          }
+        }
+
+        const planObjective = (params as Record<string, unknown>)._enrichedObjective as string | undefined ?? prompt;
+
         let legacyPlan;
         try {
           legacyPlan = planner.create({
-            objective: prompt,
+            objective: planObjective,
             scope: (params.scope as string) ?? `${intent} workflow`,
             decisions,
             tasks,
           });
+          if (legacyPlan && githubIssue) {
+            legacyPlan.githubIssue = githubIssue;
+          }
         } catch {
           // Planner creation failed — flow plan still valid
         }
@@ -271,13 +399,25 @@ export function createOrchestrateOps(
           // Store result
           entry.executionResult = executionResult;
 
-          // Start brain session
-          const session = brainIntelligence.lifecycle({
-            action: 'start',
-            domain,
-            context,
-            planId,
+          // Reuse brain session from plan_split if one exists, otherwise start new
+          const existingSession = brainIntelligence.getSessionByPlanId(planId);
+          const session =
+            existingSession && !existingSession.endedAt
+              ? existingSession
+              : brainIntelligence.lifecycle({
+                  action: 'start',
+                  domain,
+                  context,
+                  planId,
+                });
+
+          // Track execution in context health monitor
+          contextHealth.track({
+            type: 'orchestrate_execute',
+            payloadSize: JSON.stringify(executionResult).length,
           });
+          const healthStatus = contextHealth.check();
+          const healthWarning = buildHealthWarning(healthStatus, vault);
 
           return {
             plan: { id: planId, status: 'executing' },
@@ -289,19 +429,37 @@ export function createOrchestrateOps(
               toolsCalled: executionResult.toolsCalled,
               durationMs: executionResult.durationMs,
             },
+            ...(healthWarning ? { contextHealth: healthWarning } : {}),
           };
         }
 
         // Legacy path: no flow plan found, use planner directly
         const plan = planner.startExecution(planId);
-        const session = brainIntelligence.lifecycle({
-          action: 'start',
-          domain,
-          context,
-          planId,
+        // Reuse brain session from plan_split if one exists, otherwise start new
+        const existingSession = brainIntelligence.getSessionByPlanId(planId);
+        const session =
+          existingSession && !existingSession.endedAt
+            ? existingSession
+            : brainIntelligence.lifecycle({
+                action: 'start',
+                domain,
+                context,
+                planId,
+              });
+
+        // Track legacy execution in context health monitor
+        contextHealth.track({
+          type: 'orchestrate_execute_legacy',
+          payloadSize: JSON.stringify(plan).length,
         });
+        const healthStatus = contextHealth.check();
+        const healthWarning = buildHealthWarning(healthStatus, vault);
 
-        return { plan, session };
+        return {
+          plan,
+          session,
+          ...(healthWarning ? { contextHealth: healthWarning } : {}),
+        };
       },
     },
 
@@ -320,15 +478,67 @@ export function createOrchestrateOps(
           .optional()
           .default('completed')
           .describe('Plan outcome'),
+        summary: z.string().optional().describe('Completion summary — checked for rationalization language'),
         toolsUsed: z.array(z.string()).optional().describe('Tools used during execution'),
         filesModified: z.array(z.string()).optional().describe('Files modified during execution'),
+        projectPath: z.string().optional().default('.').describe('Project root path for impact analysis'),
+        overrideRationalization: z.boolean().optional().default(false)
+          .describe('Set true to bypass rationalization gate and impact warnings after review'),
       }),
       handler: async (params) => {
         const planId = params.planId as string;
         const sessionId = params.sessionId as string;
         const outcome = (params.outcome as string) ?? 'completed';
+        const completionSummary = (params.summary as string) ?? '';
         const toolsUsed = (params.toolsUsed as string[]) ?? [];
         const filesModified = (params.filesModified as string[]) ?? [];
+        const overrideRationalization = (params.overrideRationalization as boolean) ?? false;
+
+        // Anti-rationalization gate: check completion summary before completing
+        if (outcome === 'completed' && !overrideRationalization) {
+          const criteria = collectAcceptanceCriteria(planner, planId);
+          if (criteria.length > 0 && completionSummary) {
+            const report = detectRationalizations(criteria, completionSummary);
+            if (report.detected) {
+              captureRationalizationAntiPattern(vault, report);
+              return {
+                blocked: true,
+                reason: 'Rationalization language detected in completion summary',
+                rationalization: report,
+                hint: 'Address the unmet criteria, or set overrideRationalization: true to bypass this gate.',
+              };
+            }
+          }
+        }
+
+        // Impact analysis gate: assess downstream impact of modified files
+        let impactReport: ImpactReport | null = null;
+        if (filesModified.length > 0) {
+          try {
+            const analyzer = new ImpactAnalyzer();
+            const planObj = planner.get(planId);
+            const scopeHints = planObj?.scope
+              ? [planObj.scope]
+              : undefined;
+            impactReport = analyzer.analyzeImpact(
+              filesModified,
+              (params.projectPath as string) ?? '.',
+              scopeHints,
+            );
+
+            // If high risk and not overridden, warn the user
+            if (impactReport.riskLevel === 'high' && !overrideRationalization) {
+              return {
+                warning: true,
+                reason: 'High impact detected — review before completing',
+                impactReport,
+                hint: 'Review affected consumers and re-run with overrideRationalization: true or address the issues.',
+              };
+            }
+          } catch {
+            // Impact analysis is best-effort — never blocks
+          }
+        }
 
         // Complete the planner plan (legacy lifecycle)
         const plan = planner.complete(planId);
@@ -372,7 +582,13 @@ export function createOrchestrateOps(
           planStore.delete(planId);
         }
 
-        return { plan, session, extraction, epilogue: epilogueResult };
+        return {
+          plan,
+          session,
+          extraction,
+          epilogue: epilogueResult,
+          ...(impactReport ? { impactAnalysis: impactReport } : {}),
+        };
       },
     },
 
@@ -483,5 +699,178 @@ export function createOrchestrateOps(
         return { session: endedSession, extraction };
       },
     },
+
+    // ─── orchestrate_project_to_github ─────────────────────────────
+    {
+      name: 'orchestrate_project_to_github',
+      description:
+        'Project plan tasks as GitHub issues. Detects the GitHub remote, checks milestones ' +
+        'and existing issues for duplicates, creates issues with plan metadata linked, and ' +
+        'stores the projection on the plan. Opt-in: the agent suggests, user confirms.',
+      auth: 'write',
+      schema: z.object({
+        planId: z.string().describe('ID of the plan to project to GitHub'),
+        projectPath: z.string().optional().default('.').describe('Project root path for git detection'),
+        milestone: z.number().optional().describe('GitHub milestone number to assign issues to'),
+        labels: z.array(z.string()).optional().describe('Labels to apply to created issues'),
+        linkToIssue: z.number().optional().describe('Existing issue number to link plan to instead of creating new issues'),
+        dryRun: z.boolean().optional().default(false).describe('Preview what would be created without actually creating issues'),
+      }),
+      handler: async (params) => {
+        const planId = params.planId as string;
+        const projectPath = (params.projectPath as string) ?? '.';
+        const milestone = params.milestone as number | undefined;
+        const labels = (params.labels as string[]) ?? [];
+        const linkToIssue = params.linkToIssue as number | undefined;
+        const dryRun = (params.dryRun as boolean) ?? false;
+
+        // 1. Find the plan
+        const plan = planner.get(planId);
+        if (!plan) throw new Error(`Plan not found: ${planId}`);
+
+        if (plan.tasks.length === 0) {
+          throw new Error('Plan has no tasks — run plan_split first to define tasks before projecting to GitHub');
+        }
+
+        // 2. Detect GitHub context
+        const ctx = detectGitHubContext(projectPath);
+        if (!ctx) {
+          return {
+            status: 'skipped',
+            reason: 'No GitHub remote detected or gh CLI not authenticated',
+          };
+        }
+
+        const repoSlug = `${ctx.repo.owner}/${ctx.repo.repo}`;
+
+        // 3. Build plan metadata for issue body
+        const planMeta: PlanMetadataForIssue = {
+          planId: plan.id,
+          grade: plan.latestCheck?.grade ?? 'N/A',
+          score: plan.latestCheck?.score ?? 0,
+          objective: plan.objective,
+          decisions: plan.decisions,
+          tasks: plan.tasks.map((t) => ({
+            id: t.id,
+            title: t.title,
+            description: t.description,
+            dependsOn: t.dependsOn,
+          })),
+        };
+
+        // 4. Handle "link to existing issue" flow
+        if (linkToIssue) {
+          const body = formatIssueBody(planMeta, plan.objective, plan.scope);
+          if (dryRun) {
+            return {
+              status: 'dry_run',
+              action: 'update_existing',
+              repo: repoSlug,
+              issueNumber: linkToIssue,
+              bodyPreview: body.slice(0, 500),
+            };
+          }
+
+          const updated = updateGitHubIssueBody(ctx.repo, linkToIssue, body);
+          if (!updated) {
+            return {
+              status: 'error',
+              reason: `Failed to update issue #${linkToIssue}`,
+            };
+          }
+
+          const projection: GitHubProjection = {
+            repo: repoSlug,
+            issues: [{ taskId: 'all', issueNumber: linkToIssue }],
+            projectedAt: Date.now(),
+          };
+          planner.setGitHubProjection(planId, projection);
+
+          return {
+            status: 'linked',
+            repo: repoSlug,
+            issueNumber: linkToIssue,
+            message: `Plan linked to existing issue #${linkToIssue}`,
+          };
+        }
+
+        // 5. Milestone matching
+        let milestoneNumber = milestone;
+        let milestoneMatch: string | undefined;
+        if (!milestoneNumber && ctx.milestones.length > 0 && plan.scope) {
+          const match = findMatchingMilestone(plan.scope, ctx.milestones);
+          if (match) {
+            milestoneNumber = match.number;
+            milestoneMatch = match.title;
+          }
+        }
+
+        // 6. Create issues per task (with duplicate detection)
+        const created: Array<{ taskId: string; issueNumber: number; title: string }> = [];
+        const skipped: Array<{ taskId: string; title: string; existingIssue: number; reason: string }> = [];
+        const failed: Array<{ taskId: string; title: string; reason: string }> = [];
+
+        for (const task of plan.tasks) {
+          // Duplicate detection
+          const dup = findDuplicateIssue(task.title, ctx.existingIssues);
+          if (dup) {
+            skipped.push({
+              taskId: task.id,
+              title: task.title,
+              existingIssue: dup.number,
+              reason: `Existing issue #${dup.number} "${dup.title}" looks like it covers this task`,
+            });
+            continue;
+          }
+
+          const body = formatIssueBody(planMeta, task.title, task.description);
+
+          if (dryRun) {
+            created.push({ taskId: task.id, issueNumber: 0, title: task.title });
+            continue;
+          }
+
+          const issueNumber = createGitHubIssue(ctx.repo, task.title, body, {
+            milestone: milestoneNumber,
+            labels: labels.length > 0 ? labels : undefined,
+          });
+
+          if (issueNumber) {
+            created.push({ taskId: task.id, issueNumber, title: task.title });
+          } else {
+            failed.push({ taskId: task.id, title: task.title, reason: 'gh issue create failed' });
+          }
+        }
+
+        // 7. Store projection on the plan (unless dry run)
+        if (!dryRun && created.length > 0) {
+          const projection: GitHubProjection = {
+            repo: repoSlug,
+            milestone: milestoneNumber,
+            issues: created.map((c) => ({ taskId: c.taskId, issueNumber: c.issueNumber })),
+            projectedAt: Date.now(),
+          };
+          planner.setGitHubProjection(planId, projection);
+        }
+
+        return {
+          status: dryRun ? 'dry_run' : 'projected',
+          repo: repoSlug,
+          milestone: milestoneMatch
+            ? { number: milestoneNumber, title: milestoneMatch }
+            : milestoneNumber
+              ? { number: milestoneNumber }
+              : null,
+          created,
+          skipped,
+          failed,
+          context: {
+            milestonesFound: ctx.milestones.length,
+            existingIssuesChecked: ctx.existingIssues.length,
+            labelsAvailable: ctx.labels.length,
+          },
+        };
+      },
+    },
   ];
 }