@xopcai/xopc 0.0.178 → 0.0.179

package/dist/src/work/work-intake-repository.d.ts

@@ -0,0 +1,49 @@
+import type { ConfirmedWork, WorkExecutionMode, WorkIntakeProposal } from '@xopcai/gateway-contract';
+type WorkIntakeStatus = 'proposed' | 'confirmed' | 'expired' | 'cancelled';
+export interface StoredWorkIntake {
+    idempotencyKey: string;
+    requestFingerprint: string;
+    proposal: WorkIntakeProposal;
+    sessionKey?: string;
+    agentId?: string;
+    status: WorkIntakeStatus;
+    executionMode: WorkExecutionMode;
+    projectId?: string;
+    goalId?: string;
+    outcomeId?: string;
+    queueId?: string;
+    createdAt: number;
+    confirmedAt?: number;
+    updatedAt: number;
+}
+export declare class WorkIntakeRepository {
+    create(input: {
+        idempotencyKey: string;
+        requestFingerprint: string;
+        proposal: WorkIntakeProposal;
+        sessionKey?: string;
+        agentId?: string;
+        now?: number;
+    }): StoredWorkIntake;
+    get(intakeId: string, now?: number): StoredWorkIntake | undefined;
+    getByIdempotencyKey(idempotencyKey: string, now?: number): StoredWorkIntake | undefined;
+    listPendingExecution(limit?: number): StoredWorkIntake[];
+    markConfirmed(input: {
+        intakeId: string;
+        executionMode: WorkExecutionMode;
+        projectId?: string;
+        goalId: string;
+        outcomeId: string;
+        sessionKey?: string;
+        queueId?: string;
+        now?: number;
+    }): StoredWorkIntake;
+    setExecution(input: {
+        intakeId: string;
+        sessionKey?: string;
+        queueId: string;
+        now?: number;
+    }): StoredWorkIntake;
+    toConfirmedWork(stored: StoredWorkIntake): ConfirmedWork | undefined;
+}
+export {};

package/dist/src/work/work-intake-repository.js

@@ -0,0 +1,97 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+//#region src/work/work-intake-repository.ts
+function fromRow(row) {
+	return {
+		idempotencyKey: row.idempotency_key,
+		requestFingerprint: row.request_fingerprint,
+		proposal: JSON.parse(row.proposal_json),
+		...row.session_key ? { sessionKey: row.session_key } : {},
+		...row.agent_id ? { agentId: row.agent_id } : {},
+		status: row.status,
+		executionMode: row.execution_mode,
+		...row.project_id ? { projectId: row.project_id } : {},
+		...row.goal_id ? { goalId: row.goal_id } : {},
+		...row.outcome_id ? { outcomeId: row.outcome_id } : {},
+		...row.queue_id ? { queueId: row.queue_id } : {},
+		createdAt: row.created_at,
+		...row.confirmed_at === null ? {} : { confirmedAt: row.confirmed_at },
+		updatedAt: row.updated_at
+	};
+}
+function selectBy(column, value) {
+	const row = getSqliteDatabase().prepare(`SELECT * FROM work_intakes WHERE ${column} = ?`).get(value);
+	return row ? fromRow(row) : void 0;
+}
+var WorkIntakeRepository = class {
+	create(input) {
+		const now = input.now ?? Date.now();
+		return runSqliteWriteTransaction((db) => {
+			db.prepare(`INSERT INTO work_intakes (
+          intake_id, idempotency_key, request_fingerprint, objective, proposal_json, session_key, agent_id,
+          status, execution_mode, expires_at, created_at, updated_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, 'proposed', 'run_now', ?, ?, ?)
+        ON CONFLICT(idempotency_key) DO NOTHING`).run(input.proposal.id, input.idempotencyKey, input.requestFingerprint, input.proposal.objective, JSON.stringify(input.proposal), input.sessionKey ?? null, input.agentId ?? null, input.proposal.expiresAt, now, now);
+			const stored = selectBy("idempotency_key", input.idempotencyKey);
+			if (!stored) throw new Error("Failed to persist work intake");
+			return stored;
+		});
+	}
+	get(intakeId, now = Date.now()) {
+		const stored = selectBy("intake_id", intakeId);
+		if (!stored || stored.status !== "proposed" || stored.proposal.expiresAt > now) return stored;
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`UPDATE work_intakes SET status = 'expired', updated_at = ?
+         WHERE intake_id = ? AND status = 'proposed'`).run(now, intakeId);
+		});
+		return selectBy("intake_id", intakeId);
+	}
+	getByIdempotencyKey(idempotencyKey, now = Date.now()) {
+		const stored = selectBy("idempotency_key", idempotencyKey);
+		return stored ? this.get(stored.proposal.id, now) : void 0;
+	}
+	listPendingExecution(limit = 100) {
+		return getSqliteDatabase().prepare(`SELECT * FROM work_intakes
+         WHERE status = 'confirmed' AND execution_mode = 'run_now' AND queue_id IS NULL
+         ORDER BY confirmed_at ASC
+         LIMIT ?`).all(Math.min(500, Math.max(1, Math.floor(limit)))).map(fromRow);
+	}
+	markConfirmed(input) {
+		const now = input.now ?? Date.now();
+		getSqliteDatabase().prepare(`UPDATE work_intakes SET
+        status = 'confirmed', execution_mode = ?, project_id = ?, goal_id = ?,
+        outcome_id = ?, session_key = COALESCE(?, session_key), queue_id = ?,
+        confirmed_at = COALESCE(confirmed_at, ?), updated_at = ?
+       WHERE intake_id = ? AND status = 'proposed'`).run(input.executionMode, input.projectId ?? null, input.goalId, input.outcomeId, input.sessionKey ?? null, input.queueId ?? null, now, now, input.intakeId);
+		const stored = selectBy("intake_id", input.intakeId);
+		if (!stored) throw new Error("Work intake not found");
+		return stored;
+	}
+	setExecution(input) {
+		const now = input.now ?? Date.now();
+		runSqliteWriteTransaction((db) => {
+			db.prepare(`UPDATE work_intakes SET session_key = COALESCE(?, session_key), queue_id = ?, updated_at = ?
+         WHERE intake_id = ? AND status = 'confirmed'`).run(input.sessionKey ?? null, input.queueId, now, input.intakeId);
+		});
+		const stored = selectBy("intake_id", input.intakeId);
+		if (!stored) throw new Error("Work intake not found");
+		return stored;
+	}
+	toConfirmedWork(stored) {
+		if (stored.status !== "confirmed" || !stored.outcomeId || !stored.goalId) return void 0;
+		const queue = stored.queueId ? getSqliteDatabase().prepare("SELECT status, session_key FROM goal_queue WHERE queue_id = ?").get(stored.queueId) : void 0;
+		const sessionKey = queue?.session_key ?? stored.sessionKey;
+		return {
+			outcomeId: stored.outcomeId,
+			...stored.projectId ? { projectId: stored.projectId } : {},
+			goalId: stored.goalId,
+			...sessionKey ? { sessionKey } : {},
+			execution: {
+				mode: stored.executionMode,
+				status: queue?.status ?? (stored.queueId ? "queued" : "not_started"),
+				...stored.queueId ? { queueId: stored.queueId } : {}
+			}
+		};
+	}
+};
+//#endregion
+export { WorkIntakeRepository };

package/dist/src/work/work-intake-service.d.ts

@@ -0,0 +1,26 @@
+import type { ConfirmedWork, WorkExecutionMode, WorkIntakeProposal } from '@xopcai/gateway-contract';
+import { type EnqueueGoalRunOptions, type GoalQueueItemSnapshot } from '../goals/index.js';
+import { ProjectService } from '../projects/index.js';
+export interface WorkIntakeExecutionPort {
+    enqueue(goalId: string, options: EnqueueGoalRunOptions): GoalQueueItemSnapshot;
+}
+export declare class WorkIntakeService {
+    #private;
+    private readonly projects;
+    private readonly execution?;
+    constructor(projects: ProjectService, execution?: WorkIntakeExecutionPort);
+    propose(input: {
+        idempotencyKey: string;
+        objective: string;
+        projectId?: string;
+        sessionKey?: string;
+        agentId?: string;
+    }): WorkIntakeProposal;
+    confirm(input: {
+        proposalId: string;
+        executionMode: WorkExecutionMode;
+        projectId?: string;
+    }): ConfirmedWork | undefined;
+    reconcilePendingExecutions(): number;
+    private _ensureExecution;
+}

package/dist/src/work/work-intake-service.js

@@ -0,0 +1,171 @@
+import { createLogger } from "../utils/logger/index.js";
+import { init_logger } from "../utils/logger.js";
+import { runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
+import { getRelationshipSettings } from "../storage/sqlite/relationship-settings-repository.js";
+import "../storage/sqlite/index.js";
+import { GoalService } from "../goals/goal-service.js";
+import { OutcomeRepository } from "./outcome-repository.js";
+import "../goals/index.js";
+import { defineOutcomeContract } from "./outcome-contract-definition.js";
+import { WorkIntakeRepository } from "./work-intake-repository.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/work/work-intake-service.ts
+init_logger();
+const INTAKE_TTL_MS = 900 * 1e3;
+const DEFAULT_NEXT_ACTION = "Complete the first verifiable result.";
+const log = createLogger("WorkIntake");
+function outcomeContractDraft(objective) {
+	return defineOutcomeContract(objective);
+}
+function requestFingerprint(input) {
+	return createHash("sha256").update(JSON.stringify({
+		objective: input.objective.trim(),
+		projectId: input.projectId ?? null,
+		sessionKey: input.sessionKey ?? null,
+		agentId: input.agentId ?? null
+	})).digest("hex");
+}
+var WorkIntakeService = class {
+	#goals = new GoalService();
+	#outcomes = new OutcomeRepository();
+	#repository = new WorkIntakeRepository();
+	constructor(projects, execution) {
+		this.projects = projects;
+		this.execution = execution;
+	}
+	propose(input) {
+		const fingerprint = requestFingerprint(input);
+		const existing = this.#repository.getByIdempotencyKey(input.idempotencyKey);
+		if (existing) {
+			if (existing.requestFingerprint !== fingerprint) throw new Error("Idempotency key was already used for a different work intake");
+			return existing.proposal;
+		}
+		const objective = input.objective.trim();
+		if (!objective) throw new Error("Objective is required");
+		const explicitProject = input.projectId ? this.projects.get(input.projectId) : void 0;
+		if (input.projectId && !explicitProject) throw new Error("Project not found");
+		const relationship = getRelationshipSettings();
+		const contract = outcomeContractDraft(objective);
+		const proposal = {
+			id: randomUUID(),
+			objective,
+			...explicitProject ? { projectId: explicitProject.id } : {},
+			planningContext: {
+				supportMode: relationship.supportMode,
+				proactiveEnabled: relationship.proactiveEnabled
+			},
+			outcomeContract: {
+				objective: contract.objective,
+				deliverables: contract.deliverables,
+				acceptanceCriteria: contract.acceptanceCriteria,
+				constraints: contract.constraints,
+				approvalRequired: contract.approvalRequired
+			},
+			expiresAt: Date.now() + INTAKE_TTL_MS
+		};
+		const stored = this.#repository.create({
+			idempotencyKey: input.idempotencyKey,
+			requestFingerprint: fingerprint,
+			proposal,
+			sessionKey: input.sessionKey,
+			agentId: input.agentId
+		});
+		if (stored.requestFingerprint !== fingerprint) throw new Error("Idempotency key was already used for a different work intake");
+		return stored.proposal;
+	}
+	confirm(input) {
+		const intake = this.#repository.get(input.proposalId);
+		if (!intake || intake.status === "expired" || intake.status === "cancelled") return void 0;
+		if (this.#repository.toConfirmedWork(intake)) return this._ensureExecution(intake);
+		const proposal = intake.proposal;
+		runSqliteWriteTransaction(() => {
+			const selectedProjectId = input.projectId ?? proposal.projectId;
+			const existingProject = selectedProjectId ? this.projects.get(selectedProjectId) : void 0;
+			if (selectedProjectId && !existingProject) throw new Error("Project not found");
+			const contract = proposal.outcomeContract;
+			const outcome = this.#outcomes.create({
+				objective: contract.objective,
+				deliverables: contract.deliverables,
+				acceptanceCriteria: contract.acceptanceCriteria,
+				constraints: contract.constraints,
+				approvalRequired: contract.approvalRequired,
+				createdBy: "user",
+				links: [...existingProject ? [{
+					kind: "project",
+					id: existingProject.id,
+					relation: "contains"
+				}] : [], ...intake.sessionKey ? [{
+					kind: "session",
+					id: intake.sessionKey,
+					relation: "originated_from"
+				}] : []]
+			});
+			const goal = this.#goals.create({
+				outcomeId: outcome.id,
+				outcomeContractVersion: outcome.latestContractVersion,
+				title: contract.objective,
+				description: proposal.objective,
+				projectId: existingProject?.id,
+				sessionKey: intake.sessionKey,
+				agentId: intake.agentId ?? existingProject?.defaultAgentId ?? "main",
+				source: "api"
+			});
+			this.#goals.update(goal.id, { nextAction: DEFAULT_NEXT_ACTION });
+			this.#outcomes.addLink(outcome.id, {
+				kind: "goal",
+				id: goal.id,
+				relation: "drives"
+			});
+			if (existingProject && intake.sessionKey && getSessionMetadata(intake.sessionKey)) this.projects.attachSession(intake.sessionKey, existingProject.id);
+			this.#repository.markConfirmed({
+				intakeId: proposal.id,
+				executionMode: input.executionMode,
+				projectId: existingProject?.id,
+				goalId: goal.id,
+				outcomeId: outcome.id,
+				sessionKey: intake.sessionKey
+			});
+		});
+		const confirmed = this.#repository.get(proposal.id);
+		if (!confirmed) throw new Error("Failed to confirm work intake");
+		return this._ensureExecution(confirmed);
+	}
+	reconcilePendingExecutions() {
+		if (!this.execution) return 0;
+		let reconciled = 0;
+		for (const intake of this.#repository.listPendingExecution()) if (this._ensureExecution(intake).execution.queueId) reconciled += 1;
+		return reconciled;
+	}
+	_ensureExecution(intake) {
+		if (intake.status !== "confirmed") throw new Error("Work intake is not confirmed");
+		if (intake.executionMode === "run_now" && !intake.queueId) try {
+			if (!this.execution || !intake.goalId || !intake.outcomeId) throw new Error("Work execution is unavailable");
+			const queued = this.execution.enqueue(intake.goalId, {
+				source: "api",
+				executionContext: {
+					outcomeId: intake.outcomeId,
+					contextTraceId: intake.proposal.id,
+					triggerKind: "user"
+				}
+			});
+			intake = this.#repository.setExecution({
+				intakeId: intake.proposal.id,
+				sessionKey: queued.sessionKey,
+				queueId: queued.id
+			});
+		} catch (err) {
+			const errorMessage = err instanceof Error ? err.message : String(err);
+			log.warn({
+				err,
+				intakeId: intake.proposal.id,
+				goalId: intake.goalId
+			}, `Work intake was confirmed but execution could not be queued: ${errorMessage}`);
+		}
+		const work = this.#repository.toConfirmedWork(intake);
+		if (!work) throw new Error("Failed to resolve confirmed work intake");
+		return work;
+	}
+};
+//#endregion
+export { WorkIntakeService };

package/dist/src/work/work-value-metrics-service.d.ts

@@ -0,0 +1,4 @@
+import type { WorkValueMetrics } from '@xopcai/gateway-contract';
+export declare class WorkValueMetricsService {
+    get(): WorkValueMetrics;
+}

package/dist/src/work/work-value-metrics-service.js

@@ -0,0 +1,88 @@
+import { getSqliteDatabase } from "../storage/sqlite/transaction.js";
+import "../storage/sqlite/index.js";
+//#region src/work/work-value-metrics-service.ts
+function ratio(numerator, denominator) {
+	return denominator > 0 ? numerator / denominator : 0;
+}
+function count(value) {
+	return Number(value ?? 0);
+}
+var WorkValueMetricsService = class {
+	get() {
+		const weekStart = Date.now() - 10080 * 60 * 1e3;
+		const intake = getSqliteDatabase().prepare(`SELECT
+        COUNT(*) AS total,
+        SUM(CASE WHEN status = 'proposed' THEN 1 ELSE 0 END) AS proposed,
+        SUM(CASE WHEN status = 'confirmed' THEN 1 ELSE 0 END) AS confirmed,
+        SUM(CASE WHEN status = 'expired' THEN 1 ELSE 0 END) AS expired,
+        SUM(CASE WHEN status = 'confirmed' AND execution_mode = 'run_now' THEN 1 ELSE 0 END) AS run_now,
+        SUM(CASE WHEN status = 'confirmed' AND execution_mode = 'create_only' THEN 1 ELSE 0 END) AS create_only,
+        SUM(CASE WHEN queue_id IS NOT NULL THEN 1 ELSE 0 END) AS queued,
+        SUM(CASE WHEN status = 'confirmed' AND execution_mode = 'run_now' AND queue_id IS NULL THEN 1 ELSE 0 END) AS pending_queue
+       FROM work_intakes`).get();
+		const outcomes = getSqliteDatabase().prepare(`SELECT
+        COUNT(*) AS total,
+        SUM(CASE WHEN completion_verdict = 'achieved' THEN 1 ELSE 0 END) AS achieved,
+        SUM(CASE WHEN completion_verdict = 'partial' THEN 1 ELSE 0 END) AS partial,
+        SUM(CASE WHEN completion_verdict = 'not_achieved' THEN 1 ELSE 0 END) AS not_achieved,
+        SUM(CASE WHEN completion_verdict_source = 'user' THEN 1 ELSE 0 END) AS user_corrected,
+        SUM(CASE WHEN completion_verdict = 'achieved'
+                    AND verification_status = 'passed'
+                    AND completion_verdict_source != 'user'
+                    AND COALESCE(feedback_outcome, 'helpful') != 'not_helpful'
+                  THEN 1 ELSE 0 END) AS trusted,
+        SUM(CASE WHEN updated_at >= ?
+                    AND completion_verdict = 'achieved'
+                    AND verification_status = 'passed'
+                    AND completion_verdict_source != 'user'
+                    AND COALESCE(feedback_outcome, 'helpful') != 'not_helpful'
+                  THEN 1 ELSE 0 END) AS weekly_trusted
+       FROM execution_receipts
+       WHERE status != 'running'
+         AND (project_id IS NOT NULL OR goal_id IS NOT NULL OR work_item_id IS NOT NULL)`).get(weekStart);
+		const confirmed = count(intake.confirmed);
+		const intakeTotal = count(intake.total);
+		const runNow = count(intake.run_now);
+		const queued = count(intake.queued);
+		const outcomeTotal = count(outcomes.total);
+		const achieved = count(outcomes.achieved);
+		const userCorrected = count(outcomes.user_corrected);
+		const trusted = count(outcomes.trusted);
+		const weeklyTrustedProgress = count(outcomes.weekly_trusted);
+		const weeklyActiveUsers = getSqliteDatabase().prepare(`SELECT 1 FROM sessions
+       WHERE COALESCE(last_interaction_at, updated_at) >= ?
+       LIMIT 1`).get(weekStart) !== void 0 ? 1 : 0;
+		return {
+			northStar: {
+				weeklyTrustedProgress,
+				weeklyActiveUsers,
+				trustedProgressPerWeeklyActiveUser: ratio(weeklyTrustedProgress, weeklyActiveUsers)
+			},
+			intake: {
+				total: intakeTotal,
+				proposed: count(intake.proposed),
+				confirmed,
+				expired: count(intake.expired),
+				runNow,
+				createOnly: count(intake.create_only),
+				queued,
+				pendingQueueRecovery: count(intake.pending_queue),
+				confirmationRate: ratio(confirmed, intakeTotal),
+				queueRate: ratio(queued, runNow)
+			},
+			outcomes: {
+				total: outcomeTotal,
+				achieved,
+				partial: count(outcomes.partial),
+				notAchieved: count(outcomes.not_achieved),
+				userCorrected,
+				achievementRate: ratio(achieved, outcomeTotal),
+				correctionRate: ratio(userCorrected, outcomeTotal),
+				trusted,
+				trustedRate: ratio(trusted, outcomeTotal)
+			}
+		};
+	}
+};
+//#endregion
+export { WorkValueMetricsService };

package/dist/src/work-items/work-item-service.d.ts

@@ -1,4 +1,3 @@
-import type { MediaRef } from '../media/types.js';
 import type { ProactiveSignalPublisher } from '../proactive/events/publisher.js';
 import { WorkItemStore } from './work-item-store.js';
 import type { CreateWorkItemUpdateSuggestionInput, CreateWorkItemInput, UpdateWorkItemInput, WorkItem, WorkItemAttachment, WorkItemEvent, WorkItemLink, WorkItemListQuery, WorkItemListResult, WorkItemUpdateSuggestion, WorkItemUpdateSuggestionStatus } from './types.js';
@@ -27,7 +26,6 @@ export declare class WorkItemService {
         buffer: Buffer;
     } | null>;
     removeAttachment(workItemId: string, attachmentId: string): Promise<WorkItemAttachment | null>;
-    snapshotAttachmentsForGoal(workItemId: string): Promise<MediaRef[] | null>;
     createUpdateSuggestion(workItemId: string, input: CreateWorkItemUpdateSuggestionInput): WorkItemUpdateSuggestion | null;
     listUpdateSuggestions(workItemId: string, status?: WorkItemUpdateSuggestionStatus): WorkItemUpdateSuggestion[];
     applyUpdateSuggestion(id: string): {

package/dist/src/work-items/work-item-service.js

@@ -14,9 +14,6 @@ function inferAttachmentType(mimeType) {
 	if (mimeType.startsWith("video/")) return "video";
 	return "file";
 }
-function attachmentTypeForMediaRef(attachment) {
-	return attachment.type === "file" ? "document" : attachment.type;
-}
 var WorkItemService = class {
 	constructor(store = new WorkItemStore(), signals) {
 		this.store = store;
@@ -221,31 +218,6 @@ var WorkItemService = class {
 		});
 		return attachment;
 	}
-	async snapshotAttachmentsForGoal(workItemId) {
-		const item = this.store.get(workItemId);
-		if (!item) return null;
-		const refs = [];
-		for (const attachment of item.attachments ?? []) {
-			const { buffer } = await readMediaReference(attachment.mediaUri, WORK_ITEM_ATTACHMENT_MAX_BYTES);
-			const saved = await saveMediaBuffer(buffer, {
-				bucket: "inbound",
-				contentType: attachment.mimeType,
-				maxBytes: WORK_ITEM_ATTACHMENT_MAX_BYTES,
-				originalFilename: attachment.fileName
-			});
-			refs.push({
-				id: saved.id,
-				bucket: saved.bucket,
-				type: attachmentTypeForMediaRef(attachment),
-				mimeType: saved.contentType || attachment.mimeType,
-				name: attachment.fileName,
-				size: saved.size,
-				uri: saved.uri,
-				path: saved.path
-			});
-		}
-		return refs;
-	}
 	createUpdateSuggestion(workItemId, input) {
 		const suggestion = this.store.createUpdateSuggestion(workItemId, input);
 		if (!suggestion) return null;

package/dist/src/workflows/service/workflow-run-service.js

@@ -4,8 +4,8 @@ import { publishAutomationProductEvent } from "../../automations/product-events.
 import { GoalService } from "../../goals/goal-service.js";
 import "../../goals/index.js";
 import { getProjectWorkspacePathForSession } from "../../projects/workspace.js";
-import { DelegateSubagentRunner } from "../../agent/workflow/subagent-runner.js";
 import { resolveModelRef } from "../../config/agent-typed-models.js";
+import { DelegateSubagentRunner } from "../../agent/workflow/subagent-runner.js";
 import { preflightWorkflowConnectors } from "../../connectors/workflow-preflight.js";
 import { CatalogWorkflowDefinitionRegistry } from "../registry/catalog-workflow-definition-registry.js";
 import { validateWorkflowJsonSchema } from "../domain/schema-validation.js";

package/dist/src/workflows/service/workflow-session-bridge.js

@@ -6,10 +6,10 @@ import { runViewToSnapshot } from "./run-view-to-snapshot.js";
 import { GoalWorkflowJudge } from "../../goals/goal-workflow-judge.js";
 import "../../goals/index.js";
 import { getProjectWorkspacePathForSession } from "../../projects/workspace.js";
-import { isTerminalWorkflowRunStatus } from "../domain/run.js";
-import "../domain/index.js";
 import { WorkItemWorkflowJudge } from "../../work-items/work-item-workflow-judge.js";
 import "../../work-items/index.js";
+import { isTerminalWorkflowRunStatus } from "../domain/run.js";
+import "../domain/index.js";
 import { buildWorkflowRunSessionKey } from "./workflow-session-key.js";
 import { randomUUID } from "node:crypto";
 //#region src/workflows/service/workflow-session-bridge.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xopcai/xopc",
-  "version": "0.0.178",
+  "version": "0.0.179",
   "description": "Local-first AI system that remembers context, coordinates AI, and sustains long-term progress.",
   "type": "module",
   "main": "dist/src/index.js",