@xopcai/xopc 0.0.178 → 0.0.180

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

@@ -1,11 +1,11 @@
-import { extractProfileAgentId, resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
+import { extractProfileAgentId, resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { publishAutomationProductEvent } from "../../automations/product-events.js";
 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-run-service.types.d.ts

@@ -1,4 +1,4 @@
-import type { WorkflowRunInputEnvelope, WorkflowRunContextRef, WorkflowRunReplayScope, WorkflowRunSource, WorkflowRunWritebackPolicy } from '../domain/index.js';
+import type { WorkflowRunInputEnvelope, WorkflowRunContextRef, WorkflowRunReplayScope, WorkflowRunSource, WorkflowRunWritebackPolicy, WorkflowRunView } from '../domain/index.js';
 export interface StartWorkflowRunServiceParams {
     agentId: string;
     definitionId: string;
@@ -56,4 +56,6 @@ export type CancelWorkflowRunResult = CancelWorkflowRunServiceResult | WorkflowR
 /** Minimal surface for agent/automation callers (avoids importing the service class). */
 export interface WorkflowRunServiceLike {
     startWorkflowRun(params: StartWorkflowRunServiceParams): Promise<WorkflowRunServiceResult>;
+    readWorkflowRunView?(agentId: string, runId: string): Promise<WorkflowRunView | null>;
+    cancelWorkflowRun?(params: CancelWorkflowRunServiceParams): Promise<CancelWorkflowRunResult>;
 }

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.180",
   "description": "Local-first AI system that remembers context, coordinates AI, and sustains long-term progress.",
   "type": "module",
   "main": "dist/src/index.js",