pi-reason-harness 1.0.1

package/extensions/pi-reason-harness/src/lifecycle/index.ts

@@ -0,0 +1,47 @@
+/**
+ * pi-reason-harness — Lifecycle helpers
+ */
+
+import { homedir } from 'node:os';
+import * as fs from 'node:fs';
+import { join } from 'node:path';
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+
+export function getDirs() {
+  const baseDir = join(process.cwd(), '.pi', 'reason-harness');
+  return { base: baseDir };
+}
+
+export function writeSessionId(ctx: ExtensionContext): void {
+  try {
+    const dirs = getDirs();
+    const sessionId = ctx.sessionManager.getSessionId();
+    if (sessionId) {
+      if (!fs.existsSync(dirs.base)) fs.mkdirSync(dirs.base, { recursive: true });
+      fs.writeFileSync(join(dirs.base, 'session-id'), sessionId, 'utf-8');
+    }
+  } catch {}
+}
+
+export function installShellAlias(cliPath: string, projectRoot: string): void {
+  try {
+    const agentBinDir = join(homedir(), '.pi', 'agent', 'bin');
+    if (!fs.existsSync(agentBinDir)) {
+      fs.mkdirSync(agentBinDir, { recursive: true });
+    }
+    const linkPath = join(agentBinDir, 'pi-reason-harness');
+
+    const wrapperContent = `#!/bin/sh
+cd "${projectRoot}" 2>/dev/null
+exec npx tsx "${cliPath}" "$@"
+`;
+
+    let currentContent: string | null = null;
+    try {
+      currentContent = fs.readFileSync(linkPath, 'utf-8');
+    } catch {}
+    if (currentContent !== wrapperContent) {
+      fs.writeFileSync(linkPath, wrapperContent, { mode: 0o755 });
+    }
+  } catch {}
+}

package/extensions/pi-reason-harness/src/state/index.ts

@@ -0,0 +1,49 @@
+/**
+ * pi-reason-harness — Runtime state management
+ */
+
+import type { ReasonHarnessRuntime } from '../types/index.js';
+
+export function createRuntimeState(): ReasonHarnessRuntime {
+  return {
+    sessionName: null,
+    taskType: null,
+    status: 'idle',
+    iterationCount: 0,
+    bestScore: 0,
+    solved: false,
+    expertCount: 0,
+    models: [],
+    totalTokens: 0,
+    totalCost: 0,
+    adaptations: 0,
+    budget: {
+      costUsed: 0,
+      timeUsed: 0,
+      problemsSolved: 0,
+      problemsAttempted: 0,
+    },
+  };
+}
+
+export interface RuntimeStore {
+  ensure(key: string): ReasonHarnessRuntime;
+  clear(key: string): void;
+}
+
+export function createRuntimeStore(): RuntimeStore {
+  const runtimes = new Map<string, ReasonHarnessRuntime>();
+  return {
+    ensure(key: string): ReasonHarnessRuntime {
+      let runtime = runtimes.get(key);
+      if (!runtime) {
+        runtime = createRuntimeState();
+        runtimes.set(key, runtime);
+      }
+      return runtime;
+    },
+    clear(key: string): void {
+      runtimes.delete(key);
+    },
+  };
+}

package/extensions/pi-reason-harness/src/tools/index.ts

@@ -0,0 +1,88 @@
+/**
+ * pi-reason-harness — Registered tools
+ */
+
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+import { Type } from '@sinclair/typebox';
+
+export function registerTools(pi: ExtensionAPI): void {
+  pi.registerTool({
+    name: 'reason_harness_init',
+    label: 'Reason Harness Init',
+    description: 'Initialize a reasoning harness session for iterative solve-verify-feedback problem solving. Creates experts with verification strategies.',
+    parameters: Type.Object({
+      name: Type.String({ description: 'Session name' }),
+      type: Type.Union([
+        Type.Literal('code-reasoning'),
+        Type.Literal('knowledge-extraction'),
+        Type.Literal('hybrid'),
+      ], { description: 'Task type' }),
+      models: Type.Array(Type.String(), { description: 'Models to use (provider/id format, e.g. "anthropic/claude-sonnet-4-5")', default: ['openai/gpt-4o'] }),
+      numExperts: Type.Number({ description: 'Number of parallel experts', default: 1 }),
+      verification: Type.Union([
+        Type.Literal('sandbox'),
+        Type.Literal('self-audit'),
+        Type.Literal('external'),
+        Type.Literal('none'),
+      ], { description: 'Verification method', default: 'sandbox' }),
+    }),
+    execute: async (_toolCallId, params, _signal?, _onUpdate?) => {
+      const { execFile } = await import('node:child_process');
+      const payload = JSON.stringify({ action: 'init', ...params });
+      return new Promise((resolve) => {
+        execFile('pi-reason-harness', [payload], { timeout: 10000 }, (err, stdout, stderr) => {
+          if (err) {
+            resolve({ content: [{ type: 'text' as const, text: `Error: ${stderr || err.message}` }], details: {} });
+          } else {
+            resolve({ content: [{ type: 'text' as const, text: stdout.trim() }], details: {} });
+          }
+        });
+      });
+    },
+  });
+
+  pi.registerTool({
+    name: 'reason_harness_solve',
+    label: 'Reason Harness Solve',
+    description: 'Run the iterative solve-verify-feedback loop on a problem. Generates candidate solutions, verifies them, builds feedback from failures, and votes across parallel experts.',
+    parameters: Type.Object({
+      problem: Type.String({ description: 'The problem to solve' }),
+      trainInputs: Type.Array(Type.Any(), { description: 'Training input data for verification' }),
+      trainOutputs: Type.Array(Type.Any(), { description: 'Training output data (ground truth) for verification' }),
+      testInputs: Type.Array(Type.Any(), { description: 'Test input data' }),
+    }),
+    execute: async (_toolCallId, params, _signal?, _onUpdate?) => {
+      const { execFile } = await import('node:child_process');
+      const payload = JSON.stringify({ action: 'solve', ...params });
+      return new Promise((resolve) => {
+        execFile('pi-reason-harness', [payload], { timeout: 600000 }, (err, stdout, stderr) => {
+          if (err) {
+            resolve({ content: [{ type: 'text' as const, text: `Error: ${stderr || err.message}` }], details: {} });
+          } else {
+            resolve({ content: [{ type: 'text' as const, text: stdout.trim() }], details: {} });
+          }
+        });
+      });
+    },
+  });
+
+  pi.registerTool({
+    name: 'reason_harness_status',
+    label: 'Reason Harness Status',
+    description: 'Check the current reasoning harness session status, including iterations, scores, cost, and learned strategy adaptations.',
+    parameters: Type.Object({}),
+    execute: async (_toolCallId, _params, _signal?, _onUpdate?) => {
+      const { execFile } = await import('node:child_process');
+      const payload = JSON.stringify({ action: 'status' });
+      return new Promise((resolve) => {
+        execFile('pi-reason-harness', [payload], { timeout: 10000 }, (err, stdout, stderr) => {
+          if (err) {
+            resolve({ content: [{ type: 'text' as const, text: `Error: ${stderr || err.message}` }], details: {} });
+          } else {
+            resolve({ content: [{ type: 'text' as const, text: stdout.trim() }], details: {} });
+          }
+        });
+      });
+    },
+  });
+}

package/extensions/pi-reason-harness/src/types/index.ts

@@ -0,0 +1,23 @@
+/**
+ * pi-reason-harness — Shared types
+ */
+
+export interface ReasonHarnessRuntime {
+  sessionName: string | null;
+  taskType: string | null;
+  status: string;
+  iterationCount: number;
+  bestScore: number;
+  solved: boolean;
+  expertCount: number;
+  models: string[];
+  totalTokens: number;
+  totalCost: number;
+  adaptations: number;
+  budget: {
+    costUsed: number;
+    timeUsed: number;
+    problemsSolved: number;
+    problemsAttempted: number;
+  };
+}

package/extensions/pi-reason-harness/src/ui/index.ts

@@ -0,0 +1,76 @@
+/**
+ * pi-reason-harness — UI widgets
+ */
+
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { Text, truncateToWidth } from '@earendil-works/pi-tui';
+import type { ReasonHarnessRuntime } from '../types/index.js';
+
+export function createWidgetUpdater(
+  getRuntime: (ctx: ExtensionContext) => ReasonHarnessRuntime
+) {
+  return function updateWidget(extCtx: ExtensionContext): void {
+    if (!extCtx.hasUI) return;
+    const runtime = getRuntime(extCtx);
+    const width = process.stdout.columns || 120;
+
+    if (!runtime.sessionName) {
+      extCtx.ui.setWidget('reason-harness', undefined);
+      return;
+    }
+
+    extCtx.ui.setWidget('reason-harness', (_tui, theme) => {
+      const parts = [
+        theme.fg('accent', '🧠'),
+        theme.fg('text', ` ${runtime.sessionName}`),
+        theme.fg('dim', ` │ ${runtime.taskType}`),
+        theme.fg('dim', ' │ '),
+        theme.fg(
+          runtime.status === 'solving' ? 'warning' : runtime.solved ? 'success' : 'muted',
+          runtime.status
+        ),
+        theme.fg('dim', ' │ '),
+        theme.fg('muted', `E:${runtime.expertCount}`),
+        theme.fg('dim', ' │ '),
+        theme.fg(runtime.solved ? 'success' : 'warning', `★ ${runtime.bestScore.toFixed(2)}`),
+        theme.fg('dim', ` │ ${runtime.iterationCount} iters`),
+      ];
+
+      if (runtime.totalTokens > 0) {
+        const tokStr =
+          runtime.totalTokens > 1000000
+            ? `${(runtime.totalTokens / 1000000).toFixed(1)}M`
+            : runtime.totalTokens > 1000
+              ? `${(runtime.totalTokens / 1000).toFixed(1)}K`
+              : `${runtime.totalTokens}`;
+        parts.push(theme.fg('dim', ` │ ${tokStr} tok`));
+      }
+
+      if (runtime.totalCost > 0) {
+        const costStr =
+          runtime.totalCost < 0.01
+            ? `$${runtime.totalCost.toFixed(4)}`
+            : `$${runtime.totalCost.toFixed(2)}`;
+        parts.push(theme.fg('dim', ` │ ${costStr}`));
+      }
+
+      if (runtime.adaptations > 0) {
+        parts.push(theme.fg('accent', ` │ 🧠${runtime.adaptations}`));
+      }
+
+      if (runtime.solved) {
+        parts.push(theme.fg('success', ' ✓'));
+      }
+
+      parts.push(theme.fg('dim', '  (ctrl+shift+r)'));
+
+      return new Text(truncateToWidth(parts.join(''), width), width);
+    });
+  };
+}
+
+export function clearSessionUi(extCtx: ExtensionContext): void {
+  if (extCtx.hasUI) {
+    extCtx.ui.setWidget('reason-harness', undefined);
+  }
+}