pi-harness-runtime 1.1.335 → 1.1.337

package/packages/contracts/src/jobs.ts

@@ -0,0 +1,101 @@
+/**
+ * Job schemas for pi-harness
+ */
+
+import { z } from 'zod';
+import { Timestamp, UUID, NonEmptyString } from './base.js';
+
+/**
+ * Job status
+ */
+export const JobStatus = z.enum([
+  'pending',
+  'running',
+  'completed',
+  'failed',
+  'cancelled',
+]);
+
+export type JobStatus = z.infer<typeof JobStatus>;
+
+/**
+ * Job priority
+ */
+export const JobPriority = z.enum(['low', 'normal', 'high', 'urgent']);
+
+export type JobPriority = z.infer<typeof JobPriority>;
+
+/**
+ * Job definition
+ */
+export const Job = z.object({
+  id: UUID,
+  type: NonEmptyString,
+  status: JobStatus,
+  priority: JobPriority.default('normal'),
+  workspaceId: z.string(),
+  sessionId: z.string().optional(),
+  requirement: NonEmptyString,
+  result: z.unknown().optional(),
+  error: z.string().optional(),
+  progress: z.number().min(0).max(100).default(0),
+  createdAt: Timestamp,
+  startedAt: Timestamp.optional(),
+  completedAt: Timestamp.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type Job = z.infer<typeof Job>;
+
+/**
+ * Job creation input
+ */
+export const JobCreate = z.object({
+  type: NonEmptyString,
+  priority: JobPriority.default('normal'),
+  workspaceId: z.string(),
+  sessionId: z.string().optional(),
+  requirement: NonEmptyString,
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type JobCreate = z.infer<typeof JobCreate>;
+
+/**
+ * Job update input
+ */
+export const JobUpdate = z.object({
+  status: JobStatus.optional(),
+  progress: z.number().min(0).max(100).optional(),
+  result: z.unknown().optional(),
+  error: z.string().optional(),
+});
+
+export type JobUpdate = z.infer<typeof JobUpdate>;
+
+/**
+ * Job filter
+ */
+export const JobFilter = z.object({
+  workspaceId: z.string().optional(),
+  sessionId: z.string().optional(),
+  status: z.union([JobStatus, z.array(JobStatus)]).optional(),
+  priority: JobPriority.optional(),
+  since: Timestamp.optional(),
+  until: Timestamp.optional(),
+  limit: z.number().int().positive().max(100).default(50),
+  cursor: z.string().optional(),
+});
+
+export type JobFilter = z.infer<typeof JobFilter>;
+
+/**
+ * Job list response
+ */
+export const JobList = z.object({
+  items: z.array(Job),
+  nextCursor: z.string().optional(),
+  total: z.number().optional(),
+});
+
+export type JobList = z.infer<typeof JobList>;

package/packages/contracts/src/notifications.ts

@@ -0,0 +1,104 @@
+/**
+ * Notification schemas for pi-harness
+ */
+
+import { z } from 'zod';
+import { Timestamp, UUID, NonEmptyString } from './base.js';
+
+/**
+ * Notification channel
+ */
+export const NotificationChannel = z.enum([
+  'telegram',
+  'email',
+  'webhook',
+  'desktop',
+]);
+
+export type NotificationChannel = z.infer<typeof NotificationChannel>;
+
+/**
+ * Notification priority
+ */
+export const NotificationPriority = z.enum(['low', 'normal', 'high', 'urgent']);
+
+export type NotificationPriority = z.infer<typeof NotificationPriority>;
+
+/**
+ * Notification definition
+ */
+export const Notification = z.object({
+  id: UUID,
+  event: NonEmptyString,
+  channel: NotificationChannel,
+  priority: NotificationPriority.default('normal'),
+  workspaceId: z.string().optional(),
+  sessionId: z.string().optional(),
+  jobId: z.string().optional(),
+  title: NonEmptyString,
+  message: NonEmptyString,
+  data: z.record(z.string(), z.unknown()).optional(),
+  buttons: z.array(z.object({
+    text: NonEmptyString,
+    action: NonEmptyString,
+    targetId: z.string().optional(),
+    url: z.string().url().optional(),
+  })).optional(),
+  sentAt: Timestamp.optional(),
+  readAt: Timestamp.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type Notification = z.infer<typeof Notification>;
+
+/**
+ * Notification creation input
+ */
+export const NotificationCreate = z.object({
+  event: NonEmptyString,
+  channel: NotificationChannel.default('telegram'),
+  priority: NotificationPriority.default('normal'),
+  workspaceId: z.string().optional(),
+  sessionId: z.string().optional(),
+  jobId: z.string().optional(),
+  title: NonEmptyString,
+  message: NonEmptyString,
+  data: z.record(z.string(), z.unknown()).optional(),
+  buttons: z.array(z.object({
+    text: NonEmptyString,
+    action: NonEmptyString,
+    targetId: z.string().optional(),
+    url: z.string().url().optional(),
+  })).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type NotificationCreate = z.infer<typeof NotificationCreate>;
+
+/**
+ * Notification filter
+ */
+export const NotificationFilter = z.object({
+  workspaceId: z.string().optional(),
+  sessionId: z.string().optional(),
+  jobId: z.string().optional(),
+  channel: NotificationChannel.optional(),
+  priority: NotificationPriority.optional(),
+  since: Timestamp.optional(),
+  until: Timestamp.optional(),
+  limit: z.number().int().positive().max(100).default(50),
+  cursor: z.string().optional(),
+});
+
+export type NotificationFilter = z.infer<typeof NotificationFilter>;
+
+/**
+ * Notification list response
+ */
+export const NotificationList = z.object({
+  items: z.array(Notification),
+  nextCursor: z.string().optional(),
+  total: z.number().optional(),
+});
+
+export type NotificationList = z.infer<typeof NotificationList>;

package/packages/contracts/src/projects.ts

@@ -0,0 +1,81 @@
+/**
+ * Project schemas for pi-harness
+ */
+
+import { z } from 'zod';
+import { Timestamp, UUID, NonEmptyString } from './base.js';
+
+/**
+ * Project status
+ */
+export const ProjectStatus = z.enum([
+  'active',
+  'archived',
+  'deleted',
+]);
+
+export type ProjectStatus = z.infer<typeof ProjectStatus>;
+
+/**
+ * Project definition
+ */
+export const Project = z.object({
+  id: UUID,
+  name: NonEmptyString,
+  path: NonEmptyString,
+  status: ProjectStatus.default('active'),
+  workspaceId: z.string(),
+  createdAt: Timestamp,
+  updatedAt: Timestamp,
+  lastAccessedAt: Timestamp.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type Project = z.infer<typeof Project>;
+
+/**
+ * Project creation input
+ */
+export const ProjectCreate = z.object({
+  name: NonEmptyString,
+  path: NonEmptyString,
+  workspaceId: z.string(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type ProjectCreate = z.infer<typeof ProjectCreate>;
+
+/**
+ * Project update input
+ */
+export const ProjectUpdate = z.object({
+  name: NonEmptyString.optional(),
+  status: ProjectStatus.optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type ProjectUpdate = z.infer<typeof ProjectUpdate>;
+
+/**
+ * Project filter
+ */
+export const ProjectFilter = z.object({
+  workspaceId: z.string().optional(),
+  status: ProjectStatus.optional(),
+  search: z.string().optional(),
+  limit: z.number().int().positive().max(100).default(50),
+  cursor: z.string().optional(),
+});
+
+export type ProjectFilter = z.infer<typeof ProjectFilter>;
+
+/**
+ * Project list response
+ */
+export const ProjectList = z.object({
+  items: z.array(Project),
+  nextCursor: z.string().optional(),
+  total: z.number().optional(),
+});
+
+export type ProjectList = z.infer<typeof ProjectList>;

package/packages/contracts/src/sessions.ts

@@ -0,0 +1,104 @@
+/**
+ * Session schemas for pi-harness
+ */
+
+import { z } from 'zod';
+import { Timestamp, UUID, NonEmptyString } from './base.js';
+
+/**
+ * Session status
+ */
+export const SessionStatus = z.enum([
+  'active',
+  'idle',
+  'suspended',
+  'ended',
+]);
+
+export type SessionStatus = z.infer<typeof SessionStatus>;
+
+/**
+ * Session type
+ */
+export const SessionType = z.enum([
+  'interactive',
+  'batch',
+  'background',
+  'review',
+]);
+
+export type SessionType = z.infer<typeof SessionType>;
+
+/**
+ * Session definition
+ */
+export const Session = z.object({
+  id: UUID,
+  type: SessionType,
+  status: SessionStatus,
+  workspaceId: z.string(),
+  provider: NonEmptyString,
+  model: z.string().optional(),
+  startedAt: Timestamp,
+  endedAt: Timestamp.optional(),
+  lastActivityAt: Timestamp.optional(),
+  promptTokens: z.number().int().nonnegative().default(0),
+  completionTokens: z.number().int().nonnegative().default(0),
+  cost: z.number().nonnegative().default(0),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type Session = z.infer<typeof Session>;
+
+/**
+ * Session creation input
+ */
+export const SessionCreate = z.object({
+  type: SessionType.default('interactive'),
+  workspaceId: z.string(),
+  provider: NonEmptyString,
+  model: z.string().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type SessionCreate = z.infer<typeof SessionCreate>;
+
+/**
+ * Session update input
+ */
+export const SessionUpdate = z.object({
+  status: SessionStatus.optional(),
+  lastActivityAt: Timestamp.optional(),
+  promptTokens: z.number().int().nonnegative().optional(),
+  completionTokens: z.number().int().nonnegative().optional(),
+  cost: z.number().nonnegative().optional(),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+});
+
+export type SessionUpdate = z.infer<typeof SessionUpdate>;
+
+/**
+ * Session filter
+ */
+export const SessionFilter = z.object({
+  workspaceId: z.string().optional(),
+  type: SessionType.optional(),
+  status: SessionStatus.optional(),
+  since: Timestamp.optional(),
+  until: Timestamp.optional(),
+  limit: z.number().int().positive().max(100).default(50),
+  cursor: z.string().optional(),
+});
+
+export type SessionFilter = z.infer<typeof SessionFilter>;
+
+/**
+ * Session list response
+ */
+export const SessionList = z.object({
+  items: z.array(Session),
+  nextCursor: z.string().optional(),
+  total: z.number().optional(),
+});
+
+export type SessionList = z.infer<typeof SessionList>;

package/packages/cookie-sanitizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/cookie-sanitizer",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "pi-harness-runtime — cookie sanitizer (provider-quota cookie file normaliser)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/cost-optimizer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/cost-optimizer",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "Cost Optimizer for pi-harness-runtime — budget tracking, forecasting, and model selection optimization",
   "type": "module",
   "main": "./dist/index.js",

package/packages/dependency-analyzer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/dependency-analyzer",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/django-plugin/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/django-plugin",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "Django framework analysis — models, management commands, settings",
   "type": "module",
   "main": "./dist/index.js",

package/packages/doc-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/doc-generator",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "Auto-Doc Generator — generate documentation from source code (RFC-0014)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/durable-review/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@moocoding/durable-review",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "SQLite-backed durable reviewer using @earendil-works/pi-durable",
   "type": "module",
   "main": "src/index.ts",

package/packages/e2e-tester/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/e2e-tester",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "WebMCP-powered E2E testing for pi-harness - natural language test scenarios",
   "type": "module",
   "main": "./dist/index.js",

package/packages/evaluation-engine/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/evaluation-engine",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "description": "Evaluation engine for pi-harness runtime (RFC-0057)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/evaluation-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/evaluation-runner",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "type": "module",
   "description": "Framework-agnostic evaluation framework for AI outputs (RFC-0020)",
   "main": "dist/index.js",

package/packages/event-bus/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/event-bus",
-  "version": "1.1.335",
+  "version": "1.1.337",
   "type": "module",
   "main": "src/index.ts",
   "exports": {

package/packages/event-sink/dist/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Event Sink - Atomic Event Sourcing
+ *
+ * Inspired by T3Code's orchestrator event sourcing:
+ * - Commands serialize to event log
+ * - EventSink commits events + projections + outbox effects atomically
+ * - EffectWorker performs side effects AFTER intent commits
+ * - Command acknowledgement = intent committed, not work finished
+ */
+export { EventSink } from './sink.js';
+export { ProjectionStore } from './projection.js';
+export { OutboxWorker } from './outbox.js';

package/packages/event-sink/dist/index.js

@@ -0,0 +1,12 @@
+/**
+ * Event Sink - Atomic Event Sourcing
+ *
+ * Inspired by T3Code's orchestrator event sourcing:
+ * - Commands serialize to event log
+ * - EventSink commits events + projections + outbox effects atomically
+ * - EffectWorker performs side effects AFTER intent commits
+ * - Command acknowledgement = intent committed, not work finished
+ */
+export { EventSink } from './sink.js';
+export { ProjectionStore } from './projection.js';
+export { OutboxWorker } from './outbox.js';

package/packages/event-sink/dist/outbox.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Outbox Worker
+ *
+ * Processes outbox entries after events are committed.
+ * Side effects are performed asynchronously.
+ */
+import type { OutboxEntry } from './sink.js';
+/**
+ * Effect handler function
+ */
+export type EffectHandler = (payload: unknown) => Promise<void>;
+/**
+ * Outbox Worker options
+ */
+export interface OutboxWorkerOptions {
+    /** Maximum retry attempts */
+    maxRetries?: number;
+    /** Retry delay in ms */
+    retryDelay?: number;
+    /** Effect handlers */
+    handlers?: Record<string, EffectHandler>;
+}
+/**
+ * Outbox Worker
+ *
+ * Processes pending outbox entries and executes their effects.
+ */
+export declare class OutboxWorker {
+    private maxRetries;
+    private retryDelay;
+    private handlers;
+    private running;
+    private interval?;
+    constructor(options?: OutboxWorkerOptions);
+    /**
+     * Register an effect handler
+     */
+    register(effect: string, handler: EffectHandler): void;
+    /**
+     * Start processing outbox
+     */
+    start(getPending: () => Promise<OutboxEntry[]>, updateStatus: (id: string, status: OutboxEntry['status'], error?: string) => Promise<void>, pollInterval?: number): void;
+    /**
+     * Stop processing
+     */
+    stop(): void;
+    /**
+     * Check if running
+     */
+    isRunning(): boolean;
+}

package/packages/event-sink/dist/outbox.js

@@ -0,0 +1,88 @@
+/**
+ * Outbox Worker
+ *
+ * Processes outbox entries after events are committed.
+ * Side effects are performed asynchronously.
+ */
+/**
+ * Outbox Worker
+ *
+ * Processes pending outbox entries and executes their effects.
+ */
+export class OutboxWorker {
+    maxRetries;
+    retryDelay;
+    handlers = new Map();
+    running = false;
+    interval;
+    constructor(options = {}) {
+        this.maxRetries = options.maxRetries ?? 3;
+        this.retryDelay = options.retryDelay ?? 1000;
+        if (options.handlers) {
+            for (const [name, handler] of Object.entries(options.handlers)) {
+                this.handlers.set(name, handler);
+            }
+        }
+    }
+    /**
+     * Register an effect handler
+     */
+    register(effect, handler) {
+        this.handlers.set(effect, handler);
+    }
+    /**
+     * Start processing outbox
+     */
+    start(getPending, updateStatus, pollInterval = 1000) {
+        if (this.running)
+            return;
+        this.running = true;
+        this.interval = setInterval(async () => {
+            if (!this.running)
+                return;
+            try {
+                const entries = await getPending();
+                for (const entry of entries) {
+                    if (!this.running)
+                        break;
+                    if (entry.attempts >= this.maxRetries) {
+                        await updateStatus(entry.id, 'failed', 'Max retries exceeded');
+                        continue;
+                    }
+                    const handler = this.handlers.get(entry.effect);
+                    if (!handler) {
+                        await updateStatus(entry.id, 'failed', `No handler for effect: ${entry.effect}`);
+                        continue;
+                    }
+                    try {
+                        await updateStatus(entry.id, 'processing');
+                        await handler(entry.payload);
+                        await updateStatus(entry.id, 'completed');
+                    }
+                    catch (error) {
+                        await updateStatus(entry.id, 'failed', String(error));
+                    }
+                }
+            }
+            catch (error) {
+                console.error('[OutboxWorker] Error processing outbox:', error);
+            }
+        }, pollInterval);
+    }
+    /**
+     * Stop processing
+     */
+    stop() {
+        this.running = false;
+        if (this.interval) {
+            clearInterval(this.interval);
+            this.interval = undefined;
+        }
+    }
+    /**
+     * Check if running
+     */
+    isRunning() {
+        return this.running;
+    }
+}

package/packages/event-sink/dist/projection.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Projection Store
+ *
+ * Maintains materialized views of events for efficient queries.
+ * Projections are updated atomically with events.
+ */
+import type { StoredEvent } from './sink.js';
+/**
+ * Projection function type
+ */
+export type ProjectionFn<T> = (state: T | null, event: StoredEvent) => T;
+/**
+ * Projection Store
+ */
+export declare class ProjectionStore {
+    private projections;
+    /**
+     * Register a projection
+     */
+    register<T>(projection: {
+        name: string;
+        initialState: T;
+        reduce: ProjectionFn<T>;
+    }): void;
+    /**
+     * Apply events to all projections
+     */
+    apply(events: StoredEvent[]): void;
+    /**
+     * Get projection state
+     */
+    get<T>(name: string): T | null;
+    /**
+     * Reset projection to initial state
+     */
+    reset(name: string): void;
+    /**
+     * List all projection names
+     */
+    list(): string[];
+}