npm - @xopcai/xopc - Versions diffs - 0.0.180 → 0.0.188 - Mend

@xopcai/xopc 0.0.180 → 0.0.188

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (838) hide show

package/dist/gateway/static/root/index.html CHANGED Viewed

@@ -11,7 +11,7 @@
     <link rel="apple-touch-icon" sizes="180x180" href="/apple-touch-icon.png?v=20260713-1" />
     <link rel="manifest" href="/site.webmanifest?v=20260713-1" />
     <title>XOPC — Turn goals into loops. Keep what matters moving.</title>
-    <script type="module" crossorigin src="/assets/index-BA56bQ68.js"></script>
+    <script type="module" crossorigin src="/assets/index-OJgiMh07.js"></script>
     <link rel="modulepreload" crossorigin href="/assets/rolldown-runtime-aKtaBQYM.js">
     <link rel="modulepreload" crossorigin href="/assets/preload-helper-zJ_50EbN.js">
     <link rel="modulepreload" crossorigin href="/assets/vendor-react-BOUWij0V.js">
@@ -23,17 +23,17 @@
     <link rel="modulepreload" crossorigin href="/assets/createLucideIcon-DPHK1VkS.js">
     <link rel="modulepreload" crossorigin href="/assets/check-DUBLcKHA.js">
     <link rel="modulepreload" crossorigin href="/assets/middleware-Pd0e8Igk.js">
-    <link rel="modulepreload" crossorigin href="/assets/messages-H_iJjnEM.js">
-    <link rel="modulepreload" crossorigin href="/assets/locale-store-BNC8HUCI.js">
+    <link rel="modulepreload" crossorigin href="/assets/messages-D02NNLCZ.js">
+    <link rel="modulepreload" crossorigin href="/assets/locale-store-D6hs74o5.js">
     <link rel="modulepreload" crossorigin href="/assets/cn-JdwAhgNB.js">
     <link rel="modulepreload" crossorigin href="/assets/schemas-C6onAggk.js">
-    <link rel="modulepreload" crossorigin href="/assets/product-delivery-BVG-eWQO.js">
+    <link rel="modulepreload" crossorigin href="/assets/product-delivery-C8JbSj5Y.js">
     <link rel="modulepreload" crossorigin href="/assets/config-reload-event-Bjh2zoKp.js">
     <link rel="modulepreload" crossorigin href="/assets/copy-to-clipboard-HOJ79TWv.js">
-    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-CSU7UvzG.js">
-    <link rel="modulepreload" crossorigin href="/assets/activity-store-DFKtQDgE.js">
-    <link rel="modulepreload" crossorigin href="/assets/theme-store-ClDa_Bci.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-B0Tdge_q.css">
+    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-B2DmdlwO.js">
+    <link rel="modulepreload" crossorigin href="/assets/activity-store--QoUGhiS.js">
+    <link rel="modulepreload" crossorigin href="/assets/theme-store-BRxdsmic.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-Cl5n1f_U.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/package.js CHANGED Viewed

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.0.180";
+var version = "0.0.188";
 //#endregion
 export { version };

package/dist/packages/gateway-contract/src/product-delivery.js CHANGED Viewed

@@ -1,10 +1,8 @@
 import { z } from "zod";
 const ProductReferenceKindSchema = z.enum([
-	"outcome",
+	"task",
 	"project",
 	"note",
-	"work_item",
-	"goal",
 	"workflow_definition",
 	"workflow_run",
 	"automation",

package/dist/packages/gateway-contract/src/project-monitoring.js ADDED Viewed

@@ -0,0 +1,31 @@
+import { z } from "zod";
+//#region packages/gateway-contract/src/project-monitoring.ts
+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()
+});
+//#endregion
+export { ProjectMonitoringUpdateSchema };

package/dist/packages/gateway-contract/src/task-lifecycle.js ADDED Viewed

@@ -0,0 +1,67 @@
+import { z } from "zod";
+//#region packages/gateway-contract/src/task-lifecycle.ts
+const TaskPhaseSchema = z.enum([
+	"backlog",
+	"ready",
+	"active",
+	"review",
+	"closed"
+]);
+const TaskResolutionSchema = z.enum([
+	"done",
+	"cancelled",
+	"duplicate",
+	"wont_do"
+]);
+const TaskOperationalStateSchema = z.enum([
+	"idle",
+	"queued",
+	"running",
+	"waiting",
+	"verifying",
+	"blocked"
+]);
+const TaskWaitKindSchema = z.enum([
+	"dependency",
+	"user_input",
+	"approval",
+	"external_event",
+	"scheduled_time",
+	"retry_backoff",
+	"paused"
+]);
+const TaskWaitStatusSchema = z.enum([
+	"active",
+	"resolved",
+	"cancelled"
+]);
+const TaskWaitSchema = z.object({
+	id: z.string(),
+	taskId: z.string(),
+	taskRunId: z.string().optional(),
+	kind: TaskWaitKindSchema,
+	status: TaskWaitStatusSchema,
+	reason: z.string(),
+	condition: z.record(z.string(), z.unknown()),
+	resumeAt: z.number().int().nonnegative().optional(),
+	resolvedBy: z.record(z.string(), z.unknown()).optional(),
+	resolution: z.unknown().optional(),
+	createdAt: z.number().int().nonnegative(),
+	resolvedAt: z.number().int().nonnegative().optional()
+});
+const TaskAttentionKindSchema = z.enum([
+	"input_required",
+	"approval_required",
+	"dependency_blocked",
+	"run_failed",
+	"verification_failed",
+	"overdue",
+	"stale"
+]);
+const TaskAttentionItemSchema = z.object({
+	kind: TaskAttentionKindSchema,
+	summary: z.string(),
+	sourceId: z.string().optional()
+});
+//#endregion
+export { TaskAttentionItemSchema, TaskOperationalStateSchema, TaskPhaseSchema, TaskResolutionSchema, TaskWaitSchema };

package/dist/packages/gateway-contract/src/task-runs.js ADDED Viewed

@@ -0,0 +1,80 @@
+import { z } from "zod";
+//#region packages/gateway-contract/src/task-runs.ts
+const TaskExecutorKindSchema = z.enum([
+	"agent",
+	"workflow",
+	"human",
+	"external"
+]);
+const TaskRunStatusSchema = z.enum([
+	"queued",
+	"running",
+	"waiting",
+	"verifying",
+	"succeeded",
+	"failed",
+	"cancelled"
+]);
+const TERMINAL_RUN_STATUSES = new Set([
+	"succeeded",
+	"failed",
+	"cancelled"
+]);
+const TaskRunSchema = z.object({
+	id: z.string(),
+	taskId: z.string(),
+	rootRunId: z.string(),
+	parentRunId: z.string().optional(),
+	attempt: z.number().int().positive(),
+	status: TaskRunStatusSchema,
+	executorKind: TaskExecutorKindSchema,
+	executorRef: z.record(z.string(), z.unknown()),
+	trigger: z.record(z.string(), z.unknown()),
+	correlationId: z.string(),
+	causationId: z.string().optional(),
+	idempotencyKey: z.string(),
+	contractVersion: z.number().int().positive(),
+	contextSnapshotId: z.string().optional(),
+	policySnapshot: z.record(z.string(), z.unknown()).optional(),
+	sessionKey: z.string().optional(),
+	queuedAt: z.number().int().nonnegative(),
+	scheduledAt: z.number().int().nonnegative().optional(),
+	startedAt: z.number().int().nonnegative().optional(),
+	heartbeatAt: z.number().int().nonnegative().optional(),
+	completedAt: z.number().int().nonnegative().optional(),
+	timeoutAt: z.number().int().nonnegative().optional(),
+	leaseOwner: z.string().optional(),
+	leaseExpiresAt: z.number().int().nonnegative().optional(),
+	retryPolicy: z.record(z.string(), z.unknown()),
+	retryOfRunId: z.string().optional(),
+	terminalCode: z.string().optional(),
+	terminalMessage: z.string().optional(),
+	version: z.number().int().positive()
+}).superRefine((run, context) => {
+	if (!run.parentRunId && run.rootRunId !== run.id) context.addIssue({
+		code: "custom",
+		path: ["rootRunId"],
+		message: "A root run must reference itself"
+	});
+	if (run.status !== "queued" && (!run.contextSnapshotId || !run.policySnapshot)) context.addIssue({
+		code: "custom",
+		path: ["contextSnapshotId"],
+		message: "A dispatched run requires context and policy snapshots"
+	});
+	if (TERMINAL_RUN_STATUSES.has(run.status) !== Boolean(run.completedAt)) context.addIssue({
+		code: "custom",
+		path: ["completedAt"],
+		message: "Only terminal runs have a completion timestamp"
+	});
+});
+z.object({
+	id: z.string(),
+	runId: z.string(),
+	sequence: z.number().int().positive(),
+	type: z.string(),
+	payload: z.record(z.string(), z.unknown()),
+	actor: z.record(z.string(), z.unknown()),
+	occurredAt: z.number().int().nonnegative()
+});
+//#endregion
+export { TaskRunSchema };

package/dist/packages/gateway-contract/src/tasks.js ADDED Viewed

@@ -0,0 +1,353 @@
+import { TaskAttentionItemSchema, TaskOperationalStateSchema, TaskPhaseSchema, TaskResolutionSchema, TaskWaitSchema } from "./task-lifecycle.js";
+import { TaskRunSchema } from "./task-runs.js";
+import { z } from "zod";
+//#region packages/gateway-contract/src/tasks.ts
+const TaskPrioritySchema = z.enum([
+	"low",
+	"normal",
+	"high",
+	"critical"
+]);
+const TaskAcceptancePolicySchema = z.enum([
+	"verified_auto",
+	"verified_then_review",
+	"manual"
+]);
+const ActorRefSchema = z.object({
+	kind: z.enum([
+		"user",
+		"agent",
+		"system",
+		"integration"
+	]),
+	id: z.string().optional()
+});
+const TaskContractSchema = z.object({
+	taskId: z.string(),
+	version: z.number().int().positive(),
+	objective: z.string(),
+	expectedOutputs: z.array(z.string()),
+	acceptanceCriteria: z.array(z.string()),
+	constraints: z.array(z.string()),
+	approvalRequired: z.array(z.string()),
+	assumptions: z.array(z.string()),
+	risks: z.array(z.string()),
+	acceptancePolicy: TaskAcceptancePolicySchema,
+	outputDestinations: z.array(z.record(z.string(), z.unknown())),
+	createdBy: ActorRefSchema,
+	createdAt: z.number().int().nonnegative()
+});
+const TaskSchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	body: z.string().optional(),
+	phase: TaskPhaseSchema,
+	resolution: TaskResolutionSchema.optional(),
+	priority: TaskPrioritySchema,
+	dueAt: z.number().int().nonnegative().optional(),
+	projectId: z.string().optional(),
+	milestoneId: z.string().optional(),
+	parentTaskId: z.string().optional(),
+	ownerId: z.string().optional(),
+	delegateAgentId: z.string().optional(),
+	source: z.string(),
+	locale: z.enum(["en", "zh"]).optional(),
+	latestContractVersion: z.number().int().positive(),
+	version: z.number().int().positive(),
+	contract: TaskContractSchema.optional(),
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative(),
+	closedAt: z.number().int().nonnegative().optional()
+}).superRefine((task, context) => {
+	if (task.phase === "closed" !== Boolean(task.resolution)) context.addIssue({
+		code: "custom",
+		path: ["resolution"],
+		message: "Closed tasks require a resolution and open tasks cannot have one"
+	});
+});
+const TaskContextRoleSchema = z.enum([
+	"input",
+	"reference",
+	"constraint",
+	"deliverable",
+	"evidence"
+]);
+const TaskContextEdgeSchema = z.object({
+	id: z.string(),
+	taskId: z.string(),
+	targetKind: z.enum([
+		"document",
+		"file",
+		"url",
+		"session",
+		"memory",
+		"task",
+		"artifact",
+		"source"
+	]),
+	targetId: z.string(),
+	role: TaskContextRoleSchema,
+	title: z.string().optional(),
+	pinned: z.boolean(),
+	retrievalPolicy: z.record(z.string(), z.unknown()),
+	metadata: z.record(z.string(), z.unknown()),
+	createdBy: ActorRefSchema,
+	createdAt: z.number().int().nonnegative(),
+	updatedAt: z.number().int().nonnegative()
+});
+const TaskAuthorityGrantSchema = z.object({
+	id: z.string(),
+	taskId: z.string(),
+	capability: z.string(),
+	scope: z.record(z.string(), z.unknown()),
+	grantedBy: ActorRefSchema,
+	grantedAt: z.number().int().nonnegative(),
+	expiresAt: z.number().int().nonnegative().optional(),
+	revokedAt: z.number().int().nonnegative().optional()
+});
+const TaskDependencySummarySchema = z.object({
+	id: z.string(),
+	title: z.string(),
+	phase: TaskPhaseSchema,
+	resolution: TaskResolutionSchema.optional(),
+	operationalState: TaskOperationalStateSchema
+});
+const TaskEvidenceSchema = 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(),
+	provenance: z.enum([
+		"tool",
+		"external",
+		"user",
+		"judge"
+	]),
+	strength: z.enum(["observed", "verified"]),
+	observedAt: z.number().int().nonnegative()
+});
+const TaskJudgmentSchema = z.object({
+	recommendation: z.string(),
+	reasons: z.array(z.string()),
+	rejectedAlternatives: z.array(z.object({
+		option: z.string(),
+		reason: z.string()
+	})),
+	uncertainty: z.string().optional(),
+	confidence: z.number().min(0).max(1)
+});
+const TaskRunReceiptSchema = z.object({
+	runId: z.string(),
+	status: z.enum([
+		"succeeded",
+		"failed",
+		"cancelled"
+	]),
+	summary: z.string(),
+	changes: z.array(TaskEvidenceSchema),
+	evidence: z.array(TaskEvidenceSchema),
+	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(),
+	failure: z.object({
+		code: z.string(),
+		phase: z.string(),
+		recoveryAction: z.string()
+	}).optional(),
+	judgment: TaskJudgmentSchema.optional(),
+	contextTraceId: z.string().optional(),
+	finalizedAt: z.number().int().nonnegative()
+});
+const TaskExecutorSelectionSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("agent"),
+		agentId: z.string().min(1)
+	}),
+	z.object({
+		kind: z.literal("workflow"),
+		workflowId: z.string().min(1),
+		workflowVersion: z.string().min(1).optional(),
+		input: z.unknown().optional()
+	}),
+	z.object({
+		kind: z.literal("human"),
+		actorId: z.string().min(1)
+	}),
+	z.object({
+		kind: z.literal("external"),
+		provider: z.string().min(1),
+		config: z.unknown()
+	})
+]);
+const TaskContractInputSchema = TaskContractSchema.omit({
+	taskId: true,
+	version: true,
+	createdBy: true,
+	createdAt: true
+});
+const TaskContextInputSchema = TaskContextEdgeSchema.omit({
+	id: true,
+	taskId: true,
+	createdBy: true,
+	createdAt: true,
+	updatedAt: true
+});
+const TaskCreateRequestSchema = z.object({
+	idempotencyKey: z.string().trim().min(1).max(200),
+	title: z.string().trim().min(1).max(500),
+	body: z.string().trim().max(5e4).optional(),
+	projectId: z.string().trim().min(1).optional(),
+	milestoneId: z.string().trim().min(1).optional(),
+	parentTaskId: z.string().trim().min(1).optional(),
+	priority: TaskPrioritySchema.default("normal"),
+	dueAt: z.number().int().nonnegative().optional(),
+	ownerId: z.string().trim().min(1).optional(),
+	delegateAgentId: z.string().trim().min(1).optional(),
+	locale: z.enum(["en", "zh"]).optional(),
+	contract: TaskContractInputSchema,
+	dependencies: z.array(z.string().trim().min(1)).default([]),
+	context: z.array(TaskContextInputSchema).default([]),
+	authorityGrants: z.array(z.object({
+		capability: z.string().min(1),
+		scope: z.record(z.string(), z.unknown()).default({}),
+		expiresAt: z.number().int().nonnegative().optional()
+	})).default([]),
+	activation: z.discriminatedUnion("mode", [z.object({
+		mode: z.literal("capture"),
+		phase: z.enum(["backlog", "ready"]).default("backlog")
+	}), z.object({
+		mode: z.literal("start"),
+		executor: TaskExecutorSelectionSchema,
+		scheduleAt: z.number().int().nonnegative().optional()
+	})])
+}).strict();
+const TaskPatchRequestSchema = z.object({
+	expectedVersion: z.number().int().positive(),
+	title: z.string().trim().min(1).max(500).optional(),
+	body: z.string().trim().max(5e4).nullable().optional(),
+	projectId: z.string().trim().min(1).nullable().optional(),
+	milestoneId: z.string().trim().min(1).nullable().optional(),
+	parentTaskId: z.string().trim().min(1).nullable().optional(),
+	priority: TaskPrioritySchema.optional(),
+	dueAt: z.number().int().nonnegative().nullable().optional(),
+	ownerId: z.string().trim().min(1).nullable().optional(),
+	delegateAgentId: z.string().trim().min(1).nullable().optional()
+}).strict();
+const TaskWaitInputSchema = z.object({
+	kind: z.enum([
+		"dependency",
+		"user_input",
+		"approval",
+		"external_event",
+		"scheduled_time",
+		"retry_backoff",
+		"paused"
+	]),
+	reason: z.string().min(1),
+	condition: z.record(z.string(), z.unknown()).default({}),
+	resumeAt: z.number().int().nonnegative().optional()
+});
+const TaskCommandSchema = z.discriminatedUnion("type", [
+	z.object({ type: z.literal("mark_ready") }),
+	z.object({
+		type: z.literal("start"),
+		executor: TaskExecutorSelectionSchema,
+		scheduleAt: z.number().int().nonnegative().optional()
+	}),
+	z.object({ type: z.literal("request_review") }),
+	z.object({
+		type: z.literal("close"),
+		resolution: TaskResolutionSchema
+	}),
+	z.object({
+		type: z.literal("reopen"),
+		phase: z.enum(["ready", "active"])
+	}),
+	z.object({
+		type: z.literal("add_wait"),
+		wait: TaskWaitInputSchema
+	}),
+	z.object({
+		type: z.literal("resolve_wait"),
+		waitId: z.string(),
+		resolution: z.unknown().optional()
+	}),
+	z.object({
+		type: z.literal("delegate"),
+		agentId: z.string().optional()
+	}),
+	z.object({
+		type: z.literal("revise_contract"),
+		contract: TaskContractInputSchema
+	})
+]);
+const TaskCommandRequestSchema = z.object({
+	idempotencyKey: z.string().trim().min(1).max(200),
+	expectedVersion: z.number().int().positive(),
+	command: TaskCommandSchema
+}).strict();
+const TaskDependencyUpdateRequestSchema = z.object({
+	dependsOnTaskIds: z.array(z.string().trim().min(1)),
+	expectedVersion: z.number().int().positive()
+}).strict();
+z.object({
+	ok: z.literal(true),
+	items: z.array(z.object({
+		task: TaskSchema,
+		operationalState: TaskOperationalStateSchema,
+		attention: z.array(TaskAttentionItemSchema)
+	}))
+});
+z.object({
+	ok: z.literal(true),
+	task: TaskSchema,
+	operationalState: TaskOperationalStateSchema,
+	run: TaskRunSchema.optional()
+});
+z.object({
+	ok: z.literal(true),
+	task: TaskSchema,
+	operationalState: TaskOperationalStateSchema,
+	attention: z.array(TaskAttentionItemSchema),
+	waits: z.array(TaskWaitSchema),
+	runs: z.array(TaskRunSchema),
+	receipts: z.array(TaskRunReceiptSchema),
+	context: z.array(TaskContextEdgeSchema),
+	authorityGrants: z.array(TaskAuthorityGrantSchema),
+	dependencies: z.array(TaskDependencySummarySchema),
+	dependents: z.array(TaskDependencySummarySchema),
+	allowedCommands: z.array(z.string())
+});
+z.object({
+	ok: z.literal(true),
+	items: z.array(TaskRunReceiptSchema)
+});
+//#endregion
+export { TaskCommandRequestSchema, TaskCommandSchema, TaskContextInputSchema, TaskCreateRequestSchema, TaskDependencyUpdateRequestSchema, TaskExecutorSelectionSchema, TaskPatchRequestSchema };