@xopcai/xopc 0.0.180 → 0.0.188

package/dist/packages/gateway-contract/src/outcomes.js

@@ -1,137 +0,0 @@
-import { z } from "zod";
-//#region packages/gateway-contract/src/outcomes.ts
-const OutcomeUserStatusSchema = z.enum([
-	"running",
-	"needs_user",
-	"completed"
-]);
-const OutcomeInternalStatusSchema = z.enum([
-	"captured",
-	"planning",
-	"running",
-	"verifying",
-	"continuing",
-	"needs_user",
-	"blocked",
-	"paused",
-	"completed",
-	"cancelled"
-]);
-const OutcomeImportanceSchema = z.enum([
-	"low",
-	"normal",
-	"high",
-	"critical"
-]);
-const OutcomeContractSchema = z.object({
-	outcomeId: z.string(),
-	version: z.number().int().positive(),
-	objective: z.string(),
-	deliverables: z.array(z.string()),
-	acceptanceCriteria: z.array(z.string()),
-	constraints: z.array(z.string()),
-	approvalRequired: z.array(z.string()),
-	contextSnapshotId: z.string().optional(),
-	createdBy: z.enum(["user", "system"]),
-	createdAt: z.number()
-});
-const OutcomeSchema = z.object({
-	id: z.string(),
-	objective: z.string(),
-	userStatus: OutcomeUserStatusSchema,
-	internalStatus: OutcomeInternalStatusSchema,
-	importance: OutcomeImportanceSchema,
-	dueAt: z.number().optional(),
-	latestContractVersion: z.number().int().positive(),
-	latestReceiptRunId: z.string().optional(),
-	contract: OutcomeContractSchema.optional(),
-	createdAt: z.number(),
-	updatedAt: z.number()
-});
-z.object({
-	ok: z.literal(true),
-	items: z.array(OutcomeSchema)
-});
-const OutcomeActionSchema = z.enum([
-	"run",
-	"pause",
-	"resume",
-	"cancel"
-]);
-const OutcomeActionRequestSchema = z.object({ action: OutcomeActionSchema });
-const OutcomeReceiptStatusSchema = z.enum([
-	"running",
-	"completed",
-	"partial",
-	"needs_user",
-	"failed",
-	"cancelled"
-]);
-const OutcomeEvidenceSchema = z.object({
-	kind: z.enum([
-		"artifact",
-		"test",
-		"state",
-		"source"
-	]),
-	title: z.string(),
-	summary: z.string(),
-	uri: z.string().optional(),
-	verifies: z.array(z.string()).optional()
-});
-const OutcomeReceiptSchema = z.object({
-	runId: z.string(),
-	outcomeId: z.string().optional(),
-	contractVersion: z.number().int().positive().optional(),
-	sessionKey: z.string(),
-	objective: z.string(),
-	status: OutcomeReceiptStatusSchema,
-	summary: z.string(),
-	projectId: z.string().optional(),
-	goalId: z.string().optional(),
-	workItemId: z.string().optional(),
-	origin: z.string().optional(),
-	triggerKind: z.string().optional(),
-	changes: z.array(OutcomeEvidenceSchema),
-	evidence: z.array(OutcomeEvidenceSchema),
-	verification: z.object({
-		status: z.enum([
-			"passed",
-			"failed",
-			"unverified"
-		]),
-		checks: z.array(z.object({
-			criterion: z.string(),
-			status: z.enum([
-				"passed",
-				"failed",
-				"unverified"
-			]),
-			evidenceTitles: z.array(z.string())
-		}))
-	}),
-	remainingWork: z.array(z.string()),
-	nextAction: z.string().optional(),
-	needsUser: z.boolean(),
-	completionVerdict: z.enum([
-		"achieved",
-		"partial",
-		"not_achieved"
-	]).optional(),
-	correctionText: z.string().optional(),
-	contextTraceId: z.string().optional(),
-	startedAt: z.number(),
-	completedAt: z.number().optional(),
-	feedback: z.object({
-		outcome: z.enum(["helpful", "not_helpful"]),
-		reason: z.string().optional(),
-		needsCorrection: z.boolean().optional(),
-		supportFit: z.boolean().optional()
-	}).optional()
-});
-z.object({
-	ok: z.literal(true),
-	items: z.array(OutcomeReceiptSchema)
-});
-//#endregion
-export { OutcomeActionRequestSchema, OutcomeUserStatusSchema };

package/dist/packages/gateway-contract/src/work-intake.js

@@ -1,85 +0,0 @@
-import { z } from "zod";
-//#region packages/gateway-contract/src/work-intake.ts
-const WorkExecutionModeSchema = z.enum(["create_only", "run_now"]);
-const WorkExecutionStatusSchema = z.enum([
-	"not_started",
-	"queued",
-	"running",
-	"retry_waiting",
-	"succeeded",
-	"failed",
-	"skipped"
-]);
-const MonitoringModeSchema = z.enum([
-	"observe",
-	"ask_before_action",
-	"auto_low_risk"
-]);
-const QuietHoursSchema = z.object({
-	startHour: z.number().int().min(0).max(23),
-	endHour: z.number().int().min(0).max(23),
-	timezone: z.string().min(1)
-});
-z.object({
-	projectId: z.string(),
-	mode: MonitoringModeSchema,
-	quietHours: QuietHoursSchema.optional(),
-	allowedActions: z.array(z.string()),
-	confidenceThreshold: z.number().min(0).max(1),
-	scenarios: z.array(z.string()),
-	configured: z.boolean(),
-	updatedAt: z.number().optional()
-});
-const ProjectMonitoringUpdateSchema = z.object({
-	mode: MonitoringModeSchema.optional(),
-	quietHours: QuietHoursSchema.nullable().optional(),
-	allowedActions: z.array(z.string()).optional(),
-	confidenceThreshold: z.number().min(0).max(1).optional(),
-	scenarios: z.array(z.string()).optional()
-});
-z.object({
-	id: z.string(),
-	objective: z.string(),
-	projectId: z.string().optional(),
-	planningContext: z.object({
-		supportMode: z.enum([
-			"efficient",
-			"coach",
-			"companion",
-			"auto"
-		]),
-		proactiveEnabled: z.boolean()
-	}),
-	outcomeContract: z.object({
-		objective: z.string(),
-		deliverables: z.array(z.string()),
-		acceptanceCriteria: z.array(z.string()),
-		constraints: z.array(z.string()),
-		approvalRequired: z.array(z.string())
-	}),
-	expiresAt: z.number()
-});
-const WorkIntakeCreateRequestSchema = z.object({
-	idempotencyKey: z.string().min(1).max(200),
-	objective: z.string().min(1).max(12e3),
-	projectId: z.string().min(1).optional(),
-	sessionKey: z.string().min(1).optional(),
-	agentId: z.string().min(1).optional()
-});
-const WorkIntakeConfirmRequestSchema = z.object({
-	executionMode: WorkExecutionModeSchema,
-	projectId: z.string().min(1).optional()
-});
-z.object({
-	outcomeId: z.string(),
-	projectId: z.string().optional(),
-	goalId: z.string(),
-	sessionKey: z.string().optional(),
-	execution: z.object({
-		mode: WorkExecutionModeSchema,
-		status: WorkExecutionStatusSchema,
-		queueId: z.string().optional()
-	})
-});
-//#endregion
-export { ProjectMonitoringUpdateSchema, WorkIntakeConfirmRequestSchema, WorkIntakeCreateRequestSchema };

package/dist/src/agent/feedback/feedback-coordinator.d.ts

@@ -1,73 +0,0 @@
-/**
- * Feedback Coordinator - Coordinates all feedback mechanisms
- *
- * Unifies progress feedback, stream updates, and direct messages
- * into a single coherent feedback system.
- */
-import type { MessageBus } from '../../infra/bus/index.js';
-import type { SessionContext } from '../session/session-context.js';
-import type { ProgressFeedbackManager, ProgressStage } from '../lifecycle/progress.js';
-import type { StreamHandle } from '../messaging/stream-manager.js';
-export interface FeedbackCoordinatorConfig {
-    progressManager: ProgressFeedbackManager;
-    bus: MessageBus;
-}
-export declare class FeedbackCoordinator {
-    private progressManager;
-    private bus;
-    private currentStreamHandle;
-    private currentContext;
-    constructor(config: FeedbackCoordinatorConfig);
-    /**
-     * Set the current context for feedback
-     */
-    setContext(context: SessionContext): void;
-    /**
-     * Clear the current context
-     */
-    clearContext(): void;
-    /**
-     * Start a task and initialize feedback
-     */
-    startTask(): void;
-    /**
-     * End a task and cleanup feedback
-     */
-    endTask(): void;
-    /**
-     * Set the stream handle for progress updates
-     */
-    setStreamHandle(handle: StreamHandle): void;
-    /**
-     * Clear the stream handle
-     */
-    clearStreamHandle(): void;
-    /**
-     * Send progress message via stream or direct message
-     */
-    private sendProgressMessage;
-    /**
-     * Send heartbeat for long-running tasks
-     */
-    private sendHeartbeat;
-    /**
-     * Map tool name to progress stage
-     */
-    private getToolStage;
-    /**
-     * Update progress via stream
-     */
-    updateProgress(text: string, stage: ProgressStage, detail?: string): void;
-    /**
-     * Set progress stage
-     */
-    setProgress(stage: ProgressStage, detail?: string): void;
-    /**
-     * Send a direct message to the current context
-     */
-    sendMessage(content: string): Promise<void>;
-    /**
-     * Get the progress manager instance
-     */
-    getProgressManager(): ProgressFeedbackManager;
-}

package/dist/src/agent/feedback/feedback-coordinator.js

@@ -1,156 +0,0 @@
-import { createLogger } from "../../utils/logger/index.js";
-import { init_logger } from "../../utils/logger.js";
-import { formatHeartbeatMessage, formatProgressMessage } from "../lifecycle/progress.js";
-//#region src/agent/feedback/feedback-coordinator.ts
-init_logger();
-const log = createLogger("FeedbackCoordinator");
-var FeedbackCoordinator = class {
-	progressManager;
-	bus;
-	currentStreamHandle = null;
-	currentContext = null;
-	constructor(config) {
-		this.progressManager = config.progressManager;
-		this.bus = config.bus;
-	}
-	/**
-	* Set the current context for feedback
-	*/
-	setContext(context) {
-		this.currentContext = context;
-	}
-	/**
-	* Clear the current context
-	*/
-	clearContext() {
-		this.currentContext = null;
-	}
-	/**
-	* Start a task and initialize feedback
-	*/
-	startTask() {
-		this.progressManager.startTask();
-	}
-	/**
-	* End a task and cleanup feedback
-	*/
-	endTask() {
-		this.progressManager.endTask();
-		this.clearStreamHandle();
-	}
-	/**
-	* Set the stream handle for progress updates
-	*/
-	setStreamHandle(handle) {
-		this.currentStreamHandle = handle;
-		if (handle) this.progressManager.setCallbacks({
-			onProgress: (msg) => this.sendProgressMessage(msg),
-			onStreamStart: (toolName, toolArgs) => {
-				const stage = this.getToolStage(toolName);
-				if (this.currentStreamHandle?.setProgress) {
-					let detail;
-					if (toolArgs.path) detail = String(toolArgs.path);
-					else if (toolArgs.command) {
-						const cmd = String(toolArgs.command);
-						detail = cmd.length > 30 ? cmd.slice(0, 30) + "..." : cmd;
-					}
-					this.currentStreamHandle.setProgress(stage, detail);
-				}
-			},
-			onStreamEnd: () => {
-				if (this.currentStreamHandle?.setProgress) this.currentStreamHandle.setProgress("idle");
-			},
-			onHeartbeat: (elapsedMs, stage) => {
-				this.sendHeartbeat(elapsedMs, stage);
-			}
-		});
-	}
-	/**
-	* Clear the stream handle
-	*/
-	clearStreamHandle() {
-		this.currentStreamHandle = null;
-	}
-	/**
-	* Send progress message via stream or direct message
-	*/
-	async sendProgressMessage(msg) {
-		if (!this.currentContext) return;
-		if (this.currentStreamHandle?.updateProgress && msg.stage !== "idle") this.currentStreamHandle.updateProgress("", msg.stage, msg.message);
-		else if (msg.type === "error") {
-			const formatted = formatProgressMessage(msg);
-			await this.bus.publishOutbound({
-				channel: this.currentContext.channel,
-				chat_id: this.currentContext.chatId,
-				content: formatted,
-				type: "message"
-			});
-		}
-	}
-	/**
-	* Send heartbeat for long-running tasks
-	*/
-	async sendHeartbeat(elapsedMs, stage) {
-		if (!this.currentContext) return;
-		log.info({
-			elapsedMs,
-			stage
-		}, "Progress heartbeat");
-		const formatted = formatHeartbeatMessage(elapsedMs, stage);
-		await this.bus.publishOutbound({
-			channel: this.currentContext.channel,
-			chat_id: this.currentContext.chatId,
-			content: formatted,
-			type: "message"
-		});
-	}
-	/**
-	* Map tool name to progress stage
-	*/
-	getToolStage(toolName) {
-		const name = toolName.toLowerCase();
-		if (name.includes("read") || name.includes("file")) return "reading";
-		if (name.includes("search") || name.includes("grep") || name.includes("web")) return "searching";
-		if (name.includes("write") || name.includes("edit")) return "writing";
-		if (name.includes("bash") || name.includes("shell") || name.includes("exec")) return "executing";
-		return "executing";
-	}
-	/**
-	* Update progress via stream
-	*/
-	updateProgress(text, stage, detail) {
-		if (this.currentStreamHandle?.updateProgress) this.currentStreamHandle.updateProgress(text, stage, detail);
-	}
-	/**
-	* Set progress stage
-	*/
-	setProgress(stage, detail) {
-		if (this.currentStreamHandle?.setProgress) this.currentStreamHandle.setProgress(stage, detail);
-	}
-	/**
-	* Send a direct message to the current context
-	*/
-	async sendMessage(content) {
-		if (!this.currentContext) {
-			log.warn({
-				hasStreamHandle: Boolean(this.currentStreamHandle),
-				contentPreview: content.slice(0, 80)
-			}, "Outbound message skipped: no session context (setContext not called or cleared)");
-			return;
-		}
-		await this.bus.publishOutbound({
-			channel: this.currentContext.channel,
-			chat_id: this.currentContext.chatId,
-			content,
-			type: "message"
-		});
-	}
-	/**
-	* Get the progress manager instance
-	*/
-	getProgressManager() {
-		return this.progressManager;
-	}
-};
-//#endregion
-export { FeedbackCoordinator };

package/dist/src/agent/feedback/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Feedback Layer - Exports all feedback-related modules
- */
-export { FeedbackCoordinator, type FeedbackCoordinatorConfig } from './feedback-coordinator.js';

package/dist/src/agent/feedback/index.js

@@ -1,2 +0,0 @@
-import { FeedbackCoordinator } from "./feedback-coordinator.js";
-export { FeedbackCoordinator };

package/dist/src/agent/goals/checklist-judge.d.ts

@@ -1,48 +0,0 @@
-import type { GoalUiLocale } from './goal-locale.js';
-export type DecomposeChecklistResult = {
-    items: {
-        text: string;
-    }[];
-    parseFailed: boolean;
-    errorReason?: string;
-};
-export declare function decomposeGoalChecklist(opts: {
-    goal: string;
-    existingChecklist?: string;
-    judgeModelRef: string;
-    signal?: AbortSignal;
-    judgeTimeoutMs?: number;
-    uiLocale?: GoalUiLocale;
-}): Promise<DecomposeChecklistResult>;
-export type ChecklistJudgeUpdate = {
-    index: number;
-    status: 'completed' | 'impossible';
-    evidence?: string | null;
-};
-export type ChecklistEvaluateParsed = {
-    verdict: 'continue' | 'done' | 'blocked' | 'needs_input';
-    confidence: number;
-    updates: ChecklistJudgeUpdate[];
-    newItems: {
-        text: string;
-    }[];
-    reason: string;
-    nextAction?: string;
-    missingEvidence?: string[];
-    userQuestion?: string;
-};
-export type EvaluateChecklistResult = {
-    parsed: ChecklistEvaluateParsed;
-    parseFailed: boolean;
-};
-export declare function evaluateGoalChecklistJudge(opts: {
-    goal: string;
-    numberedChecklist: string;
-    lastResponse: string;
-    historyExcerpt: string;
-    goalContextExcerpt?: string;
-    judgeModelRef: string;
-    signal?: AbortSignal;
-    judgeTimeoutMs?: number;
-    uiLocale?: GoalUiLocale;
-}): Promise<EvaluateChecklistResult>;