npm - @xopcai/xopc - Versions diffs - 0.0.179 → 0.0.187 - Mend

@xopcai/xopc 0.0.179 → 0.0.187

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 (794) 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-BDzspHrg.js"></script>
+    <script type="module" crossorigin src="/assets/index-vi5KlR5_.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-DYqBwJAK.js">
-    <link rel="modulepreload" crossorigin href="/assets/locale-store-DIVc0AQs.js">
+    <link rel="modulepreload" crossorigin href="/assets/messages-CPxz48hr.js">
+    <link rel="modulepreload" crossorigin href="/assets/locale-store-Bff30u5V.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-CKKL96r_.js">
-    <link rel="modulepreload" crossorigin href="/assets/activity-store-A5FUMjeV.js">
-    <link rel="modulepreload" crossorigin href="/assets/theme-store-DtwI_VLT.js">
-    <link rel="stylesheet" crossorigin href="/assets/index-B0Tdge_q.css">
+    <link rel="modulepreload" crossorigin href="/assets/gateway-startup-retry-CntXJF6W.js">
+    <link rel="modulepreload" crossorigin href="/assets/activity-store-WlR2zEvA.js">
+    <link rel="modulepreload" crossorigin href="/assets/theme-store-y7e_tvYi.js">
+    <link rel="stylesheet" crossorigin href="/assets/index-D-YfWVyS.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/package.js CHANGED Viewed

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.0.179";
+var version = "0.0.187";
 //#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 };

package/dist/src/activity/types.d.ts CHANGED Viewed

@@ -1,4 +1,4 @@
-export type ActivityObjectKind = 'project' | 'note' | 'work_item' | 'session' | 'goal' | 'workflow_run' | 'automation';
+export type ActivityObjectKind = 'project' | 'note' | 'session' | 'task' | 'workflow_run' | 'automation';
 export type ActivityVisibility = 'timeline' | 'audit' | 'debug';
 export type ActivityImportance = 'low' | 'normal' | 'high';
 export type ActivityPrincipalKind = 'user' | 'agent' | 'system' | 'automation' | 'workflow';
@@ -8,7 +8,7 @@ export type ActivityScopeReason = 'explicit' | 'object_owner' | 'inherited_sessi
 export type ActivityRelatedProjectReason = 'object_link' | 'session_link' | 'derived_context';
 export type ObjectLinkRelation = 'belongs_to' | 'created_from' | 'discussed_in' | 'attached_to';
 export type ObjectLinkSource = 'user' | 'agent' | 'system';
-export type ActivityEventType = 'project.created' | 'project.updated' | 'project.status_changed' | 'project.workspace_changed' | 'note.created' | 'note.appended' | 'note.updated' | 'note.status_changed' | 'note.preview_generated' | 'work_item.created' | 'work_item.updated' | 'work_item.status_changed' | 'work_item.archived' | 'work_item.link_added' | 'session.attached_to_project' | 'session.detached_from_project' | 'session.renamed' | 'goal.created' | 'goal.status_changed' | 'workflow_run.started' | 'workflow_run.completed' | 'automation.run_started' | 'automation.run_completed' | 'work_discovery.started' | 'work_discovery.completed' | 'work_discovery.failed' | 'work_discovery.canceled' | 'work_discovery.suggestion_selected' | (string & {});
+export type ActivityEventType = 'project.created' | 'project.updated' | 'project.status_changed' | 'project.workspace_changed' | 'note.created' | 'note.appended' | 'note.updated' | 'note.status_changed' | 'note.preview_generated' | 'session.attached_to_project' | 'session.detached_from_project' | 'session.renamed' | 'task.created' | 'task.created.v2' | 'task.commanded.v2' | 'task.phase_changed.v2' | 'task.attention_required.v2' | 'workflow_run.started' | 'workflow_run.completed' | 'automation.run_started' | 'automation.run_completed' | 'work_discovery.started' | 'work_discovery.completed' | 'work_discovery.failed' | 'work_discovery.canceled' | 'work_discovery.suggestion_selected' | (string & {});
 export interface ActivityPrincipal {
     kind: ActivityPrincipalKind;
     id?: string;

package/dist/src/agent/agent-instance-gateway.d.ts CHANGED Viewed

@@ -39,7 +39,7 @@ export interface AgentInstanceGateway {
     /** Last assistant text from the in-memory agent (empty when no agent / no assistant yet). */
     getLastAssistantContent(sessionKey: string): string | null;
     /** Build the bounded, policy-filtered context used for this model turn. */
-    prepareUserTurnContext(userMessage: AgentMessage, sessionKey: string): Promise<import('./memory/context/types.js').UserContextPlan>;
+    prepareUserTurnContext(userMessage: AgentMessage, sessionKey: string, turnId: string): Promise<import('./memory/context/types.js').UserContextPlan>;
     /** Post-turn: sync external memory providers, queue next prefetch. */
     afterAgentTurn(sessionKey: string, userPlainText: string): Promise<import('./memory/understanding/types.js').UnderstandingReviewResult | undefined>;
     /** Bump the per-session "turns since memory review" counter. */

package/dist/src/agent/agent-manager.d.ts CHANGED Viewed

@@ -18,7 +18,6 @@ import type { AutomationService } from '../automations/index.js';
 import type { SessionStore } from '../session/store.js';
 import type { NotesService } from '../notes/index.js';
 import type { ProjectService } from '../projects/index.js';
-import type { WorkItemService } from '../work-items/index.js';
 import type { SessionContext } from './session/session-context.js';
 import type { Skill, SkillDiagnostic, SkillMarkdownPreviewPayload, SkillRuntimeStatus } from './skills/types.js';
 import { type SkillHubLockEntry } from './skills/hub-lock.js';
@@ -30,8 +29,10 @@ export interface SkillCatalogEntry {
     description: string;
     category?: string;
     source: Skill['source'];
+    origin: Skill['origin']['id'];
     path: string;
     managed: boolean;
+    writable: boolean;
     /** User toggle in ~/.xopc/skills.json (`entries[name].enabled`). Default true. */
     enabled: boolean;
     /** When true, skill is never injected into `<available_skills>` (SKILL.md frontmatter). */
@@ -88,8 +89,8 @@ export interface AgentManagerConfig {
     /** Gateway: exposes first-class xopc product objects for the `xopc_use` tool. */
     getNotesService?: () => NotesService | undefined;
     getProjectService?: () => ProjectService | undefined;
-    getWorkItemService?: () => WorkItemService | undefined;
     getLocalAppService?: () => import('../local-apps/index.js').LocalAppService | undefined;
+    dispatchTaskRuns?: () => void;
     /** Gateway: starts persisted workflow runs (dedicated chat session per run). */
     getWorkflowRunService?: () => import('../workflows/service/workflow-run-service.types.js').WorkflowRunServiceLike | undefined;
     /** Runtime notification for UI/CLI shells that cache skill catalogs. */
@@ -153,6 +154,7 @@ export declare class AgentManager implements AgentInstanceGateway {
     private pendingSkillsUpdatedReason;
     private projectTrustStore;
     constructor(config: AgentManagerConfig);
+    private isUserContextEnabledForSession;
     private computeBaseWorkspacePath;
     /**
      * Workspace root for inbound attachments / side effects for this session's agent id.
@@ -190,7 +192,7 @@ export declare class AgentManager implements AgentInstanceGateway {
     getMemoryManagerForSession(sessionKey: string): MemoryManager;
     markCodeIntelligenceDirty(sessionKey: string, paths: readonly string[]): void;
     /** Build the bounded, policy-filtered context used for this model turn. */
-    prepareUserTurnContext(userMessage: AgentMessage, sessionKey: string): Promise<UserContextPlan>;
+    prepareUserTurnContext(userMessage: AgentMessage, sessionKey: string, turnId: string): Promise<UserContextPlan>;
     /**
      * After a completed turn: sync external providers and queue next-turn prefetch.
      * Delegates to {@link UserContextCoordinator}.
@@ -230,7 +232,8 @@ export declare class AgentManager implements AgentInstanceGateway {
     /**
      * Reload skills from disk and refresh system prompt on all active Agent instances.
      */
-    refreshSkillsAfterDiskChange(source?: 'explicit' | 'watch'): void;
+    refreshSkillsAfterDiskChange(source?: 'explicit' | 'watch' | 'trust'): void;
+    refreshSkillsAfterTrustChange(): void;
     private scheduleSkillsUpdated;
     private applySkillsAfterDiskChange;
     /**