@xopcai/xopc 0.0.180 → 0.0.188

package/dist/src/user-context/memory-episode-evaluator.js

@@ -0,0 +1,35 @@
+//#region src/user-context/memory-episode-evaluator.ts
+function coverage(expected, actual) {
+	if (expected.length === 0) return 1;
+	return expected.filter((item) => actual.has(item)).length / expected.length;
+}
+function evaluateMemoryEpisode(episode, observation) {
+	const recalled = new Set(observation.recalledRecordIds);
+	const lifecycle = new Set(observation.lifecycleActions);
+	const dreaming = new Set(observation.dreamingActions);
+	const forbiddenRecall = episode.forbiddenRecall.filter((recordId) => recalled.has(recordId));
+	const missingLifecycle = episode.expectedLifecycle.filter((action) => !lifecycle.has(action));
+	const missingDreaming = episode.expectedDreaming.filter((action) => !dreaming.has(action));
+	const recall = coverage(episode.expectedRecall, recalled);
+	const safe = forbiddenRecall.length === 0 && observation.scopeViolations === 0 && observation.sensitivityViolations === 0;
+	return {
+		id: episode.id,
+		recall,
+		forbiddenRecall,
+		missingLifecycle,
+		missingDreaming,
+		safe,
+		passed: safe && recall === 1 && missingLifecycle.length === 0 && missingDreaming.length === 0
+	};
+}
+function evaluateMemoryEpisodeSuite(cases) {
+	const results = cases.map(({ episode, observation }) => evaluateMemoryEpisode(episode, observation));
+	const averageRecall = results.length > 0 ? results.reduce((total, result) => total + result.recall, 0) / results.length : 0;
+	return {
+		releaseReady: results.length > 0 && results.every((result) => result.passed),
+		averageRecall,
+		results
+	};
+}
+//#endregion
+export { evaluateMemoryEpisode, evaluateMemoryEpisodeSuite };

package/dist/src/user-context/memory-readiness.d.ts

@@ -0,0 +1,33 @@
+export type MemoryReadinessReason = 'insufficient_feedback' | 'low_helpful_rate' | 'high_record_error_rate' | 'sensitive_feedback_detected' | 'insufficient_dreaming_runs' | 'high_dreaming_failure_rate';
+export interface MemoryReadinessMetrics {
+    evaluatedTurns: number;
+    helpfulTurns: number;
+    recordFeedback: number;
+    recordErrors: number;
+    sensitiveFeedback: number;
+    dreamingRuns: number;
+    dreamingFailures: number;
+}
+export interface MemoryReadinessThresholds {
+    minEvaluatedTurns: number;
+    minHelpfulRate: number;
+    maxRecordErrorRate: number;
+    minDreamingRuns: number;
+    maxDreamingFailureRate: number;
+}
+export interface MemoryReadiness {
+    ready: boolean;
+    reasons: MemoryReadinessReason[];
+    metrics: MemoryReadinessMetrics & {
+        helpfulRate: number | null;
+        recordErrorRate: number | null;
+        dreamingFailureRate: number | null;
+    };
+    thresholds: MemoryReadinessThresholds;
+    evaluatedAt: string;
+}
+export declare const MEMORY_READINESS_THRESHOLDS: MemoryReadinessThresholds;
+export declare function evaluateMemoryReadiness(metrics: MemoryReadinessMetrics, options?: {
+    thresholds?: Partial<MemoryReadinessThresholds>;
+    nowMs?: number;
+}): MemoryReadiness;

package/dist/src/user-context/memory-readiness.js

@@ -0,0 +1,41 @@
+//#region src/user-context/memory-readiness.ts
+const MEMORY_READINESS_THRESHOLDS = {
+	minEvaluatedTurns: 20,
+	minHelpfulRate: .75,
+	maxRecordErrorRate: .1,
+	minDreamingRuns: 10,
+	maxDreamingFailureRate: .1
+};
+function rate(numerator, denominator) {
+	return denominator > 0 ? Math.round(numerator / denominator * 1e4) / 1e4 : null;
+}
+function evaluateMemoryReadiness(metrics, options = {}) {
+	const thresholds = {
+		...MEMORY_READINESS_THRESHOLDS,
+		...options.thresholds
+	};
+	const helpfulRate = rate(metrics.helpfulTurns, metrics.evaluatedTurns);
+	const recordErrorRate = rate(metrics.recordErrors, metrics.recordFeedback);
+	const dreamingFailureRate = rate(metrics.dreamingFailures, metrics.dreamingRuns);
+	const reasons = [];
+	if (metrics.evaluatedTurns < thresholds.minEvaluatedTurns) reasons.push("insufficient_feedback");
+	else if (helpfulRate === null || helpfulRate < thresholds.minHelpfulRate) reasons.push("low_helpful_rate");
+	if (recordErrorRate !== null && recordErrorRate > thresholds.maxRecordErrorRate) reasons.push("high_record_error_rate");
+	if (metrics.sensitiveFeedback > 0) reasons.push("sensitive_feedback_detected");
+	if (metrics.dreamingRuns < thresholds.minDreamingRuns) reasons.push("insufficient_dreaming_runs");
+	else if (dreamingFailureRate === null || dreamingFailureRate > thresholds.maxDreamingFailureRate) reasons.push("high_dreaming_failure_rate");
+	return {
+		ready: reasons.length === 0,
+		reasons,
+		metrics: {
+			...metrics,
+			helpfulRate,
+			recordErrorRate,
+			dreamingFailureRate
+		},
+		thresholds,
+		evaluatedAt: new Date(options.nowMs ?? Date.now()).toISOString()
+	};
+}
+//#endregion
+export { MEMORY_READINESS_THRESHOLDS, evaluateMemoryReadiness };

package/dist/src/user-context/memory-use-audit.js

@@ -8,8 +8,9 @@ function summarizeMemoryUseAudit(traces) {
 	for (const trace of injects) {
 		selectedRecords += trace.selectedRecordIds.length;
 		if (trace.skippedReason) skippedReasons[trace.skippedReason] = (skippedReasons[trace.skippedReason] ?? 0) + 1;
-		if (trace.feedback?.outcome === "helpful") helpful += 1;
-		if (trace.feedback?.outcome === "not_helpful" || trace.feedback?.outcome === "irrelevant") notHelpful += 1;
+		const responseFeedback = trace.feedback.find((item) => item.level === "response");
+		if (responseFeedback?.rating === "helpful") helpful += 1;
+		if (responseFeedback?.rating === "not_helpful" || responseFeedback?.rating === "irrelevant") notHelpful += 1;
 	}
 	return {
 		total: traces.length,

package/dist/src/user-context/projection.d.ts

@@ -4,6 +4,7 @@ import type { KnowledgeSourceItem, KnowledgeSyncRun } from '../knowledge/types.j
 import type { ConnectorLearningJob } from '../storage/sqlite/index.js';
 export type UserContextFacet = 'basics' | 'collaboration' | 'boundaries' | 'priorities' | 'people' | 'current';
 export type UserContextOrigin = 'told_by_you' | 'observed' | 'inferred' | 'connected_source';
+export declare const USER_CONTEXT_MEMORY_KINDS: readonly MemoryKind[];
 export declare function isUserContextRecord(record: MemoryRecord): boolean;
 export declare function isUserContextMemoryKind(value: unknown): value is MemoryKind;
 export declare function facetForMemoryKind(kind: MemoryKind): UserContextFacet;
@@ -16,6 +17,19 @@ export declare function projectUserContextRecord(record: MemoryRecord): {
     status: import("../agent/memory/types.js").MemoryStatus;
     origin: UserContextOrigin;
     sourceName: string;
+    scope: {
+        type: "session";
+        id: string;
+    } | {
+        type: "project";
+        id: string;
+    } | {
+        type: "workspace";
+        id: string;
+    } | {
+        type: "global";
+        id?: undefined;
+    };
     updatedAt: string;
     sensitivity: import("../agent/memory/types.js").MemorySensitivity;
     explicitness: import("../agent/memory/types.js").MemoryExplicitness;

package/dist/src/user-context/projection.js

@@ -20,6 +20,7 @@ const CONTEXTUAL_USER_KINDS = new Set([
 	"derived_insight",
 	"task_lesson"
 ]);
+const USER_CONTEXT_MEMORY_KINDS = [...ALWAYS_PERSONAL_KINDS, ...CONTEXTUAL_USER_KINDS];
 function isUserContextRecord(record) {
 	if (ALWAYS_PERSONAL_KINDS.has(record.kind)) return true;
 	return CONTEXTUAL_USER_KINDS.has(record.kind) && record.tags?.includes("user-understanding") === true;
@@ -72,6 +73,16 @@ function projectUserContextRecord(record) {
 		status: effectiveMemoryStatus(record),
 		origin: originForMemoryRecord(record),
 		sourceName: record.source.provider ?? "local",
+		scope: record.scope.sessionKey ? {
+			type: "session",
+			id: record.scope.sessionKey
+		} : record.scope.projectId ? {
+			type: "project",
+			id: record.scope.projectId
+		} : record.scope.workspaceId ? {
+			type: "workspace",
+			id: record.scope.workspaceId
+		} : { type: "global" },
 		updatedAt: record.updatedAt,
 		sensitivity: record.sensitivity ?? "normal",
 		explicitness: record.explicitness,
@@ -98,6 +109,7 @@ function recordsDerivedFromPersonalContextSource(records, sourceInstanceId) {
 	return records.filter((record) => record.source.sourceInstanceId === sourceInstanceId && isUserContextRecord(record));
 }
 function connectionIdentityKey(connection) {
+	if (connection.accountId) return `account:${connection.accountId}`;
 	const email = typeof connection.identity.email === "string" ? connection.identity.email.trim().toLocaleLowerCase() : "";
 	if (email) return `email:${email}`;
 	const username = typeof connection.identity.username === "string" ? connection.identity.username.trim().toLocaleLowerCase() : "";
@@ -138,8 +150,8 @@ function projectPersonalContextSources(definitions, instances, knowledge = {}) {
 			return (left.connectedAt ?? left.createdAt).localeCompare(right.connectedAt ?? right.createdAt) || left.id.localeCompare(right.id);
 		});
 		return (accounts.length > 0 ? accounts.map((connection, index) => ({
-			instanceId: connection.id,
-			sourceInstanceId: `composio:${definition.id}:${connection.id}`,
+			instanceId: connection.accountId,
+			sourceInstanceId: connection.accountId ? `composio:${definition.id}:${connection.accountId}` : void 0,
 			accountLabel: connection.alias ?? (typeof connection.identity.email === "string" ? connection.identity.email : void 0) ?? (typeof connection.identity.username === "string" ? connection.identity.username : void 0),
 			accountOrdinal: index + 1,
 			accountCount: accounts.length,
@@ -247,4 +259,4 @@ function projectPersonalContextSources(definitions, instances, knowledge = {}) {
 	});
 }
 //#endregion
-export { facetForMemoryKind, isPersonalContextConnector, isUserContextMemoryKind, isUserContextRecord, originForMemoryRecord, projectPersonalContextSources, projectUserContextRecord, recordsDerivedFromPersonalContextSource };
+export { USER_CONTEXT_MEMORY_KINDS, facetForMemoryKind, isPersonalContextConnector, isUserContextMemoryKind, isUserContextRecord, originForMemoryRecord, projectPersonalContextSources, projectUserContextRecord, recordsDerivedFromPersonalContextSource };

package/dist/src/user-context/relationship-continuity.js

@@ -43,7 +43,7 @@ function buildRelationshipContinuityPrompt(records, nowMs = Date.now()) {
 	if (!due.length) return "";
 	return [
 		"## Relationship continuity",
-		"The user explicitly asked for these follow-ups. Check in naturally when relevant; do not pretend to know an outcome.",
+		"The user explicitly asked for these follow-ups. Check in naturally when relevant; do not pretend to know an task.",
 		...due.map((record) => `- ${record.content}`)
 	].join("\n");
 }

package/dist/src/user-context/runtime.d.ts

@@ -1,8 +1,6 @@
 import type { Config } from '../config/schema.js';
-import { BuiltinMemoryStore } from '../agent/memory/builtin-memory-store.js';
 import type { MemoryManager } from '../agent/memory/manager.js';
 export interface UserContextRuntime {
-    builtinMemoryStore: BuiltinMemoryStore;
     memoryManager: MemoryManager;
 }
 /** Owns the process-wide user context runtime shared by every agent and workspace. */

package/dist/src/user-context/runtime.js

@@ -1,11 +1,7 @@
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
-import { init_paths, resolveUserDir } from "../config/paths.js";
-import { resolveBuiltinMemoryStoreConfig } from "../agent/memory/memory-config.js";
-import { BuiltinMemoryStore } from "../agent/memory/builtin-memory-store.js";
 import { createMemoryManagerFromConfig } from "../agent/memory/create-memory-manager.js";
 //#region src/user-context/runtime.ts
-init_paths();
 init_logger();
 const log = createLogger("UserContextRuntimeRegistry");
 /** Owns the process-wide user context runtime shared by every agent and workspace. */
@@ -13,12 +9,7 @@ var UserContextRuntimeRegistry = class {
 	runtime;
 	getOrCreate(config) {
 		if (this.runtime) return this.runtime;
-		const userContextRoot = resolveUserDir();
-		const builtinMemoryStore = new BuiltinMemoryStore(resolveBuiltinMemoryStoreConfig(userContextRoot, config));
-		this.runtime = {
-			builtinMemoryStore,
-			memoryManager: createMemoryManagerFromConfig(userContextRoot, builtinMemoryStore, config)
-		};
+		this.runtime = { memoryManager: createMemoryManagerFromConfig(config) };
 		return this.runtime;
 	}
 	async clear() {

package/dist/src/user-context/source-recommendations.d.ts

@@ -1,13 +1,13 @@
 import type { ConnectorDefinition } from '../connectors/types.js';
-type GoalSummary = {
+type TaskSummary = {
     id: string;
     title: string;
-    description?: string;
+    body?: string;
 };
-export declare function buildGoalSourceRecommendations(definitions: ConnectorDefinition[], installedConnectorIds: Set<string>, goals: GoalSummary[]): {
+export declare function buildTaskSourceRecommendations(definitions: ConnectorDefinition[], installedConnectorIds: Set<string>, tasks: TaskSummary[]): {
     sourceId: string;
     sourceName: string;
-    goalId: string;
-    goalTitle: string;
+    taskId: string;
+    taskTitle: string;
 }[];
 export {};

package/dist/src/user-context/source-recommendations.js

@@ -53,9 +53,10 @@ const DOMAINS = [
 		"沟通"
 	]
 ];
-function buildGoalSourceRecommendations(definitions, installedConnectorIds, goals) {
+function buildTaskSourceRecommendations(definitions, installedConnectorIds, tasks) {
 	const recommendations = [];
 	for (const definition of definitions) {
+		if (definition.understanding?.mode !== "activity") continue;
 		if (installedConnectorIds.has(definition.id)) continue;
 		const sourceText = [
 			definition.id,
@@ -63,17 +64,17 @@ function buildGoalSourceRecommendations(definitions, installedConnectorIds, goal
 			definition.description,
 			...definition.tags ?? []
 		].join(" ").toLowerCase();
-		for (const goal of goals) {
-			const goalText = `${goal.title} ${goal.description ?? ""}`.toLowerCase();
+		for (const task of tasks) {
+			const taskText = `${task.title} ${task.body ?? ""}`.toLowerCase();
 			let score = 0;
-			for (const keywords of DOMAINS) if (keywords.some((keyword) => sourceText.includes(keyword)) && keywords.some((keyword) => goalText.includes(keyword))) score += 3;
-			const genericTerms = goalText.match(/[a-z][a-z0-9_-]{3,}/g) ?? [];
+			for (const keywords of DOMAINS) if (keywords.some((keyword) => sourceText.includes(keyword)) && keywords.some((keyword) => taskText.includes(keyword))) score += 3;
+			const genericTerms = taskText.match(/[a-z][a-z0-9_-]{3,}/g) ?? [];
 			score += new Set(genericTerms.filter((term) => sourceText.includes(term))).size;
 			if (score > 0) recommendations.push({
 				sourceId: definition.id,
 				sourceName: definition.displayName,
-				goalId: goal.id,
-				goalTitle: goal.title,
+				taskId: task.id,
+				taskTitle: task.title,
 				score
 			});
 		}
@@ -81,4 +82,4 @@ function buildGoalSourceRecommendations(definitions, installedConnectorIds, goal
 	return recommendations.sort((left, right) => right.score - left.score || left.sourceName.localeCompare(right.sourceName)).filter((item, index, all) => all.findIndex((candidate) => candidate.sourceId === item.sourceId) === index).slice(0, 3).map(({ score: _score, ...item }) => item);
 }
 //#endregion
-export { buildGoalSourceRecommendations };
+export { buildTaskSourceRecommendations };

package/dist/src/voice/local/model-files.js

@@ -2,8 +2,8 @@ import { dirname, join } from "node:path";
 import { createReadStream, createWriteStream } from "node:fs";
 import { createHash } from "node:crypto";
 import { mkdir, rm, stat } from "node:fs/promises";
-import { pipeline } from "node:stream/promises";
 import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
 //#region src/voice/local/model-files.ts
 function resolveModelFileUrl(remoteHost, model, file) {
 	const base = remoteHost.endsWith("/") ? remoteHost : `${remoteHost}/`;

package/dist/src/voice/stt/transcribe-core.js

@@ -16,8 +16,8 @@ function classifyFailureReason(reason) {
 function toAttempt(attempt) {
 	return {
 		provider: attempt.provider ?? "unknown",
-		outcome: attempt.outcome,
-		reasonCode: attempt.outcome === "success" ? "success" : classifyFailureReason(attempt.reason),
+		task: attempt.task,
+		reasonCode: attempt.task === "success" ? "success" : classifyFailureReason(attempt.reason),
 		latencyMs: attempt.latencyMs ?? 0,
 		...attempt.reason ? { error: attempt.reason } : {}
 	};
@@ -49,7 +49,7 @@ async function transcribe(audioBuffer, config, options) {
 			attempts,
 			attemptedProviders
 		}, "All STT providers failed");
-		const lastError = attempts.find((a) => a.outcome === "failed")?.error;
+		const lastError = attempts.find((a) => a.task === "failed")?.error;
 		throw new Error(lastError ?? "All STT providers failed");
 	}
 	const chosen = attachmentDecision.chosen;

package/dist/src/voice/stt/types.d.ts

@@ -44,11 +44,11 @@ export interface STTConfig {
     /** Hard timeout per provider call (ms). Default 60s. */
     timeoutMs?: number;
 }
-export type STTProviderAttemptOutcome = 'success' | 'skipped' | 'failed';
+export type STTProviderAttemptTask = 'success' | 'skipped' | 'failed';
 export type STTProviderFailureReason = 'success' | 'not_configured' | 'timeout' | 'provider_error' | 'unsupported_format' | 'unknown';
 export interface STTProviderAttempt {
     provider: string;
-    outcome: STTProviderAttemptOutcome;
+    task: STTProviderAttemptTask;
     reasonCode: STTProviderFailureReason;
     latencyMs: number;
     error?: string;

package/dist/src/voice/tts/speak-core.js

@@ -133,7 +133,7 @@ async function speak(text, config, options) {
 		if (typeof resolved.plugin.synthesize !== "function") {
 			attempts.push({
 				provider: resolved.providerId,
-				outcome: "skipped",
+				task: "skipped",
 				reasonCode: "not_configured",
 				latencyMs: Date.now() - startTime,
 				error: `Provider "${resolved.providerId}" does not implement synthesize()`
@@ -150,7 +150,7 @@ async function speak(text, config, options) {
 			const durationSeconds = (Date.now() - startTime) / 1e3;
 			attempts.push({
 				provider: resolved.providerId,
-				outcome: "success",
+				task: "success",
 				reasonCode: "success",
 				latencyMs: Date.now() - startTime
 			});
@@ -181,7 +181,7 @@ async function speak(text, config, options) {
 			const errorMsg = error instanceof Error ? error.message : String(error);
 			attempts.push({
 				provider: resolved.providerId,
-				outcome: "failed",
+				task: "failed",
 				reasonCode,
 				latencyMs,
 				error: errorMsg
@@ -214,7 +214,7 @@ async function speakWithProvider(text, config, providerName, options) {
 		...toTtsResult(resolved, await resolved.plugin.synthesize(request), (Date.now() - startTime) / 1e3),
 		attempts: [{
 			provider: providerName,
-			outcome: "success",
+			task: "success",
 			reasonCode: "success",
 			latencyMs: Date.now() - startTime
 		}],

package/dist/src/voice/tts/types.d.ts

@@ -112,13 +112,13 @@ export interface TtsDirectiveOverrides {
     };
 }
 /** Provider attempt result (TTS fallback chain) */
-export type ProviderAttemptOutcome = 'success' | 'skipped' | 'failed';
+export type ProviderAttemptTask = 'success' | 'skipped' | 'failed';
 /** Provider failure reason classification */
 export type ProviderFailureReason = 'success' | 'not_configured' | 'timeout' | 'provider_error' | 'text_too_long' | 'unknown';
 /** Single provider attempt in a TTS fallback chain */
 export interface ProviderAttempt {
     provider: string;
-    outcome: ProviderAttemptOutcome;
+    task: ProviderAttemptTask;
     reasonCode: ProviderFailureReason;
     latencyMs: number;
     error?: string;

package/dist/src/work-discovery/analyzer.js

@@ -50,7 +50,7 @@ function validateSuggestion(value, allowedPaths) {
 	const actionType = item.actionType === "summarize_recent_work" || item.actionType === "inspect_related_tests" || item.actionType === "plan_next_step" ? item.actionType : "plan_next_step";
 	const risk = item.risk === "command" || item.risk === "file_write" ? item.risk : "analysis";
 	const estimatedMinutes = typeof item.estimatedMinutes === "number" && Number.isFinite(item.estimatedMinutes) ? Math.max(1, Math.min(30, Math.round(item.estimatedMinutes))) : 3;
-	const expectedOutcome = typeof item.expectedOutcome === "string" && item.expectedOutcome.trim() ? item.expectedOutcome.trim().slice(0, 500) : item.title.trim().slice(0, 120);
+	const expectedTask = typeof item.expectedTask === "string" && item.expectedTask.trim() ? item.expectedTask.trim().slice(0, 500) : item.title.trim().slice(0, 120);
 	const evidence = Array.isArray(item.evidence) ? item.evidence.flatMap((raw) => {
 		if (!raw || typeof raw !== "object") return [];
 		const candidate = raw;
@@ -70,7 +70,7 @@ function validateSuggestion(value, allowedPaths) {
 		evidence,
 		actionPrompt: item.actionPrompt.trim().slice(0, 2e3),
 		confidence,
-		expectedOutcome,
+		expectedTask,
 		estimatedMinutes,
 		risk,
 		verification: strings(item.verification, 4).map((entry) => entry.slice(0, 300))
@@ -175,10 +175,10 @@ async function analyzeWorkContext(input) {
 			"topicKey is a short stable topic identifier. evidenceRefs must use exact relative paths from the snapshot or git://recent-state.",
 			"Distinguish one-off recent edits from work sustained across multiple days. Prefer one current thread and only add ongoing or long_term threads when evidence supports them.",
 			"For a normal result, suggestions must contain exactly 3 materially different next steps.",
-			"Each suggestion must include actionType, title, rationale, evidence, actionPrompt, confidence, expectedOutcome, estimatedMinutes, risk, and verification.",
+			"Each suggestion must include actionType, title, rationale, evidence, actionPrompt, confidence, expectedTask, estimatedMinutes, risk, and verification.",
 			"actionType must be summarize_recent_work, inspect_related_tests, or plan_next_step.",
 			"risk must be analysis, command, or file_write. estimatedMinutes is an integer from 1 to 30.",
-			"verification is a short array describing how the user can tell the outcome is real.",
+			"verification is a short array describing how the user can tell the task is real.",
 			"Each evidence item contains an optional exact relative path from the snapshot and one concrete observation.",
 			"actionPrompt asks the assistant to investigate or continue the step; it does not silently authorize file changes.",
 			"If the current objective is unclear or fewer than three credible suggestions exist, set lowConfidence=true, return suggestions=[], and ask one concise contextQuestion.",
@@ -311,7 +311,7 @@ function workDiscoveryResultMarkdown(result) {
 	}
 	lines.push("", "## Suggested next steps");
 	for (const [index, suggestion] of result.suggestions.entries()) {
-		lines.push("", `### ${index + 1}. ${suggestion.title}`, "", suggestion.rationale, "", `Expected outcome: ${suggestion.expectedOutcome}`, "");
+		lines.push("", `### ${index + 1}. ${suggestion.title}`, "", suggestion.rationale, "", `Expected task: ${suggestion.expectedTask}`, "");
 		for (const evidence of suggestion.evidence) lines.push(`- ${evidence.path ? `\`${evidence.path}\`: ` : ""}${evidence.observation}`);
 	}
 	return lines.join("\n");

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

@@ -48,7 +48,7 @@ export declare class WorkDiscoveryService {
     revokeDirectorySource(id: string): import("./types.js").WorkDiscoveryDirectorySource;
     importPersonalContext(rawItems: unknown[], signal?: AbortSignal, runId?: string): Promise<{
         profileCandidates: {
-            status: "pending" | "accepted";
+            status: "pending";
             memoryRecordId: string;
             id: string;
             category: "role" | "focus" | "technology" | "workflow" | "preference";
@@ -57,15 +57,6 @@ export declare class WorkDiscoveryService {
             evidence: string[];
         }[];
         workThreads: import("./types.js").WorkUnderstandingThread[];
-        autoRemembered: {
-            status: "pending" | "accepted";
-            memoryRecordId: string;
-            id: string;
-            category: "role" | "focus" | "technology" | "workflow" | "preference";
-            statement: string;
-            confidence: "high" | "medium" | "low";
-            evidence: string[];
-        }[];
     }>;
     updatePersonalContextProfile(input: {
         decisions: Array<{

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

@@ -265,7 +265,6 @@ var WorkDiscoveryService = class {
 		const safeWorkThreadCandidates = analysis.workThreadCandidates.filter((candidate) => !hasLongVerbatimOverlap(candidate.title, rawContents) && !hasLongVerbatimOverlap(candidate.summary, rawContents));
 		const agentId = getDefaultAgentId(this.options.getConfig());
 		const profileCandidates = safeProfileCandidates.map((candidate) => {
-			const autoRemember = candidate.confidence === "high" && candidate.category !== "focus" && candidate.evidence.length >= 2;
 			const record = upsertMemoryRecord({
 				providerId: "local",
 				kind: candidate.category === "preference" ? "preference" : candidate.category === "workflow" ? "routine" : "derived_insight",
@@ -281,7 +280,7 @@ var WorkDiscoveryService = class {
 					"personal-context",
 					`work-discovery:${candidate.category}`
 				],
-				status: autoRemember ? "active" : "candidate",
+				status: "candidate",
 				sensitivity: "normal",
 				explicitness: "inferred",
 				durability: candidate.category === "focus" ? "ephemeral" : candidate.category === "workflow" ? "recurring" : "durable",
@@ -290,7 +289,7 @@ var WorkDiscoveryService = class {
 			});
 			return {
 				...candidate,
-				status: autoRemember ? "accepted" : "pending",
+				status: "pending",
 				memoryRecordId: record.id
 			};
 		});
@@ -348,8 +347,7 @@ var WorkDiscoveryService = class {
 		}, "Personal context analyzed");
 		return {
 			profileCandidates,
-			workThreads,
-			autoRemembered: profileCandidates.filter((candidate) => candidate.status === "accepted")
+			workThreads
 		};
 	}
 	updatePersonalContextProfile(input) {
@@ -803,7 +801,7 @@ var WorkDiscoveryService = class {
 	preserveMemoryRecord(record, patch) {
 		return upsertMemoryRecord({
 			id: record.id,
-			providerId: "local",
+			providerId: record.providerId,
 			kind: record.kind,
 			sourceAgentId: record.provenance.sourceAgentId,
 			workspaceId: record.scope.workspaceId,

package/dist/src/work-discovery/types.d.ts

@@ -138,7 +138,7 @@ export interface WorkDiscoverySuggestion {
     evidence: WorkDiscoveryEvidence[];
     actionPrompt: string;
     confidence: 'high' | 'medium' | 'low';
-    expectedOutcome: string;
+    expectedTask: string;
     estimatedMinutes: number;
     risk: 'analysis' | 'command' | 'file_write';
     verification: string[];

package/dist/src/workflows/domain/run.d.ts

@@ -24,7 +24,6 @@ export interface WorkflowRunMetadata {
     triggerSource: WorkflowRunSource['kind'];
     agentId?: string;
     projectId?: string;
-    workItemId?: string;
     contextRefs?: WorkflowRunContextRef[];
     writebackPolicy?: WorkflowRunWritebackPolicy;
     retryOfRunId?: string;
@@ -34,11 +33,11 @@ export interface WorkflowRunMetadata {
     correlation?: WorkflowRunCorrelation;
     origin?: WorkflowRunOrigin;
     schedule?: WorkflowRunScheduleMetadata;
-    goalId?: string;
+    taskRunId?: string;
 }
 export type WorkflowRunReplayScope = 'failed_agents' | 'failed_phases';
 export interface WorkflowRunContextRef {
-    kind: 'project' | 'goal' | 'work_item' | 'session' | 'attachment' | 'memory';
+    kind: 'project' | 'task' | 'session' | 'attachment' | 'memory';
     id: string;
     role?: string;
     title?: string;
@@ -47,7 +46,7 @@ export interface WorkflowRunWritebackPolicy {
     targets: WorkflowRunWritebackTarget[];
 }
 export interface WorkflowRunWritebackTarget {
-    kind: 'project' | 'goal' | 'work_item';
+    kind: 'project' | 'task';
     id: string;
     mode: 'record' | 'suggest' | 'evaluate';
 }

package/dist/src/workflows/draft/workflow-draft-prompt.js

@@ -32,7 +32,7 @@ Shape:
   "name": "lowercase_snake_case",
   "graph": { "schemaVersion": 1, "nodes": [], "edges": [] },
   "manifest": {
-    "title": "Human title", "description": "Outcome in plain language", "version": "1.0.0",
+    "title": "Human title", "description": "Task in plain language", "version": "1.0.0",
     "inputSchema": { "type": "object", "properties": {}, "required": [] },
     "defaults": { "concurrency": 3, "timeoutSec": 1800, "maxSubagents": 8 },
     "permissions": { "network": false, "fileSystem": "read", "approvalRequired": false },

package/dist/src/workflows/index.js

@@ -1,4 +1,3 @@
-import { runViewToSnapshot } from "./service/run-view-to-snapshot.js";
 import { DEFAULT_WORKFLOW_CONCURRENCY, DEFAULT_WORKFLOW_MAX_SUBAGENTS, DEFAULT_WORKFLOW_TIMEOUT_SEC, buildWorkflowDefinition, deriveWorkflowPhases, hashWorkflowStableValue, normalizeWorkflowDefinitionId, toWorkflowDefinitionTitle } from "./domain/definition-utils.js";
 import { validateWorkflowDefinitionInput, validateWorkflowGraph } from "./domain/validation.js";
 import { CatalogWorkflowDefinitionRegistry } from "./registry/catalog-workflow-definition-registry.js";
@@ -13,6 +12,7 @@ import { resolveWorkflowRootDir, resolveWorkflowRunArtifactsDir, resolveWorkflow
 import { WorkflowEventStore, createWorkflowEventStore } from "./store/event-store.js";
 import { WorkflowRunStore, createWorkflowRunStore } from "./store/run-store.js";
 import { WorkflowRunService, buildWorkflowRunDefinitionSnapshot, buildWorkflowRunInputEnvelope, buildWorkflowRunMetadata, extractWorkflowRunSessionKey, resolveWorkflowReplayTargets } from "./service/workflow-run-service.js";
+import { runViewToSnapshot } from "./service/run-view-to-snapshot.js";
 import { buildWorkflowRunSessionKey, readWorkflowRunIdFromSessionCustomData } from "./service/workflow-session-key.js";
 import { WORKFLOW_RUN_LINK_CONTEXT_KIND, WORKFLOW_SESSION_TYPE, WorkflowSessionBridge, formatParentRunLinkText } from "./service/workflow-session-bridge.js";
 import "./registry/index.js";

package/dist/src/workflows/service/workflow-run-service.d.ts

@@ -22,6 +22,7 @@ export declare class WorkflowRunService {
     private readonly definitionRegistry;
     private readonly emittedTerminalAutomationEvents;
     constructor(options: WorkflowRunServiceOptions);
+    dispatchTaskRuns(): Promise<void>;
     startWorkflowRun(params: StartWorkflowRunServiceParams): Promise<WorkflowRunServiceResult>;
     retryWorkflowRun(params: RetryWorkflowRunServiceParams): Promise<WorkflowRunServiceResult>;
     replayWorkflowRun(params: ReplayWorkflowRunServiceParams): Promise<WorkflowRunServiceResult>;
@@ -38,9 +39,8 @@ export declare function buildWorkflowRunInputEnvelope(input: unknown, goal?: str
 export declare function buildWorkflowRunMetadata(params: {
     definition: WorkflowDefinition;
     agentId: string;
-    goalId?: string;
+    taskRunId?: string;
     projectId?: string;
-    workItemId?: string;
     contextRefs?: WorkflowRunMetadata['contextRefs'];
     writebackPolicy?: WorkflowRunMetadata['writebackPolicy'];
     sessionKey: string;