@xopcai/xopc 0.0.161 → 0.0.162

package/dist/src/gateway/hono/routes/browser-workflows.js

@@ -0,0 +1,78 @@
+//#region src/gateway/hono/routes/browser-workflows.ts
+function presentWorkflow(service, recipe) {
+	const inputs = service.validate(recipe.yaml).document?.args ?? {};
+	return {
+		id: recipe.id,
+		name: recipe.name,
+		description: recipe.description,
+		enabled: recipe.status === "published",
+		risk: recipe.risk,
+		domains: recipe.domains,
+		inputs,
+		createdAtMs: recipe.createdAtMs,
+		updatedAtMs: recipe.updatedAtMs
+	};
+}
+function presentRun(run) {
+	return {
+		id: run.id,
+		workflowId: run.recipeId,
+		status: run.status,
+		inputs: run.args,
+		result: run.result,
+		error: run.error,
+		createdAtMs: run.createdAtMs,
+		startedAtMs: run.startedAtMs,
+		endedAtMs: run.endedAtMs,
+		durationMs: run.durationMs
+	};
+}
+function registerBrowserWorkflowRoutes(authenticated, deps) {
+	const service = deps.service.browserRecipes;
+	authenticated.get("/api/browser/workflows", (c) => c.json({ workflows: service.list().map((recipe) => presentWorkflow(service, recipe)) }));
+	authenticated.get("/api/browser/workflows/:id", (c) => {
+		const recipe = service.get(c.req.param("id"));
+		return recipe ? c.json({ workflow: presentWorkflow(service, recipe) }) : c.json({ error: "Browser automation not found" }, 404);
+	});
+	authenticated.patch("/api/browser/workflows/:id", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const current = service.get(c.req.param("id"));
+			if (!current) return c.json({ error: "Browser automation not found" }, 404);
+			const body = await c.req.json().catch(() => null);
+			if (typeof body?.enabled !== "boolean") return c.json({ error: "enabled must be a boolean" }, 400);
+			const workflow = service.save({
+				yaml: current.yaml,
+				status: body.enabled ? "published" : "disabled",
+				expectedId: current.id
+			});
+			return c.json({ workflow: presentWorkflow(service, workflow) });
+		} catch (error) {
+			return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+		}
+	});
+	authenticated.delete("/api/browser/workflows/:id", deps.strictRateLimitMiddleware, (c) => {
+		try {
+			return c.json({ removed: service.remove(c.req.param("id")) });
+		} catch (error) {
+			return c.json({ error: error instanceof Error ? error.message : String(error) }, 409);
+		}
+	});
+	authenticated.post("/api/browser/workflows/:id/run", deps.strictRateLimitMiddleware, async (c) => {
+		try {
+			const body = await c.req.json().catch(() => ({}));
+			if (body.inputs !== void 0 && (!body.inputs || typeof body.inputs !== "object" || Array.isArray(body.inputs))) return c.json({ error: "inputs must be an object" }, 400);
+			const run = service.startRun(c.req.param("id"), body.inputs ?? {});
+			return c.json({ run: presentRun(run) }, 202);
+		} catch (error) {
+			return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
+		}
+	});
+	authenticated.get("/api/browser/workflow-runs", (c) => c.json({ runs: service.listRuns(c.req.query("workflowId")).map(presentRun) }));
+	authenticated.get("/api/browser/workflow-runs/:id", (c) => {
+		const run = service.getRun(c.req.param("id"));
+		return run ? c.json({ run: presentRun(run) }) : c.json({ error: "Run not found" }, 404);
+	});
+	authenticated.post("/api/browser/workflow-runs/:id/cancel", deps.strictRateLimitMiddleware, (c) => c.json({ cancelled: service.cancel(c.req.param("id")) }));
+}
+//#endregion
+export { registerBrowserWorkflowRoutes };

package/dist/src/gateway/hono/routes/home.js

@@ -59,6 +59,7 @@ function triggerLabel(automation) {
 }
 function actionLabel(automation) {
 	if (automation.action.kind === "workflow") return `workflow:${automation.action.workflowId}`;
+	if (automation.action.kind === "browser_recipe") return `browser-workflow:${automation.action.recipeId}`;
 	return automation.action.agentId ? `agent:${automation.action.agentId}` : "agent";
 }
 function toHomeAutomation(automation) {

package/dist/src/gateway/hono/routes/index.js

@@ -6,6 +6,8 @@ import { registerMemoryRoutes } from "./memory.js";
 import { registerProjectsRoutes } from "./projects.js";
 import { registerSearchRoutes } from "./search.js";
 import { registerMobileRoutes } from "./mobile.js";
+import { registerTaskOutcomeRoutes } from "./task-outcomes.js";
+import { registerInteractionStateRoutes } from "./interaction-state.js";
 import { registerLocalAppsRoutes } from "./local-apps.js";
 import { registerWorkDiscoveryRoutes } from "./work-discovery.js";
 import { mountAppLazyRoutePrefixes, registerAuthenticatedLazyRouteFallback } from "./lazy-fallback.js";
@@ -21,6 +23,8 @@ function registerCoreAuthenticatedRoutes(authenticated, deps) {
 	registerWorkDiscoveryRoutes(authenticated, deps);
 	registerSearchRoutes(authenticated, deps);
 	registerMobileRoutes(authenticated, deps);
+	registerTaskOutcomeRoutes(authenticated, deps);
+	registerInteractionStateRoutes(authenticated, deps);
 }
 function registerAuthenticatedRoutes(app, authenticated, deps) {
 	registerCoreAuthenticatedRoutes(authenticated, deps);

package/dist/src/gateway/hono/routes/interaction-state.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerInteractionStateRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/interaction-state.js

@@ -0,0 +1,45 @@
+import { getInteractionState, setInteractionState } from "../../../storage/sqlite/interaction-state-repository.js";
+import "../../../storage/sqlite/index.js";
+//#region src/gateway/hono/routes/interaction-state.ts
+const SUPPORT_NEEDS = new Set([
+	"listen",
+	"clarify",
+	"advise",
+	"act",
+	"unknown"
+]);
+function registerInteractionStateRoutes(authenticated, deps) {
+	authenticated.get("/api/interaction-state", (c) => {
+		const sessionKey = c.req.query("sessionKey")?.trim() ?? "";
+		if (!sessionKey) return c.json({ error: "sessionKey is required" }, 400);
+		const state = getInteractionState(sessionKey);
+		return state ? c.json({
+			ok: true,
+			state
+		}) : c.json({
+			ok: false,
+			error: "Interaction state not found"
+		}, 404);
+	});
+	authenticated.patch("/api/interaction-state", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => null);
+		const sessionKey = body && typeof body === "object" && typeof body.sessionKey === "string" ? body.sessionKey.trim() : "";
+		const supportNeed = body && typeof body === "object" && SUPPORT_NEEDS.has(body.supportNeed) ? body.supportNeed : void 0;
+		if (!sessionKey || !supportNeed) return c.json({ error: "sessionKey and a valid supportNeed are required" }, 400);
+		const state = setInteractionState({
+			sessionKey,
+			signal: {
+				supportNeed,
+				confidence: 1,
+				source: "explicit",
+				repairStatus: "none"
+			}
+		});
+		return c.json({
+			ok: true,
+			state
+		});
+	});
+}
+//#endregion
+export { registerInteractionStateRoutes };

package/dist/src/gateway/hono/routes/lazy-bundles.js

@@ -43,6 +43,14 @@ const AUTHENTICATED_LAZY_ROUTE_BUNDLES = [
 			return { register: registerBrowserInstallRoutes };
 		}
 	},
+	{
+		id: "browser-workflows",
+		match: (path) => startsWithAny(path, ["/api/browser/workflows", "/api/browser/workflow-runs"]),
+		load: async () => {
+			const { registerBrowserWorkflowRoutes } = await import("./browser-workflows.js");
+			return { register: registerBrowserWorkflowRoutes };
+		}
+	},
 	{
 		id: "browser",
 		match: (path) => startsWithAny(path, ["/api/browser"]),

package/dist/src/gateway/hono/routes/memory.js

@@ -1,4 +1,6 @@
+import { setInteractionState } from "../../../storage/sqlite/interaction-state-repository.js";
 import { LOCAL_USER_ID } from "../../../user-context/owner.js";
+import { findTaskOutcomeForAssistant, setTaskOutcomeFeedback } from "../../../storage/sqlite/task-outcome-repository.js";
 import { appendMemorySignal, appendMemoryTraceEvent, deleteMemoryRecord, findLatestMemoryInjectTrace, getMemoryRecord, listMemoryRecords, listMemorySignals, listMemoryTraceEvents, searchMemoryRecords, setLatestMemoryInjectFeedback, setMemoryTraceFeedback, summarizeMemoryRecallFeedback, summarizeUserUnderstandingQuality, upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
 import { listKnowledgeSourceChanges, listKnowledgeSourceItems, listKnowledgeSyncRuns } from "../../../storage/sqlite/knowledge-repository.js";
 import "../../../storage/sqlite/index.js";
@@ -10,6 +12,7 @@ import { discoverMemoryPlugins } from "../../../agent/memory/plugin-discovery.js
 import { createMemoryManagerFromConfig } from "../../../agent/memory/create-memory-manager.js";
 import { resolveAdaptiveUnderstandingCadence } from "../../../agent/memory/understanding/quality.js";
 import { isUserContextRecord, projectUserContextRecord } from "../../../user-context/projection.js";
+import { summarizeMemoryUseAudit } from "../../../user-context/memory-use-audit.js";
 //#region src/gateway/hono/routes/memory.ts
 init_agent_scope();
 init_config();
@@ -310,6 +313,13 @@ function registerMemoryRoutes(authenticated, deps) {
 		});
 		return c.json({ traces });
 	});
+	authenticated.get("/api/user-context/memory-use-audit", (c) => {
+		const traces = listMemoryTraceEvents({
+			sessionKey: c.req.query("sessionKey") || void 0,
+			limit: parseLimit(c.req.query("limit"))
+		});
+		return c.json({ audit: summarizeMemoryUseAudit(traces) });
+	});
 	authenticated.patch("/api/user-context/traces/:traceId/feedback", async (c) => {
 		const body = await c.req.json().catch(() => ({}));
 		const outcome = typeof body.outcome === "string" && MEMORY_TRACE_FEEDBACK_OUTCOMES.has(body.outcome) ? body.outcome : void 0;
@@ -353,6 +363,24 @@ function registerMemoryRoutes(authenticated, deps) {
 		const outcome = body.outcome === "helpful" || body.outcome === "not_helpful" ? body.outcome : void 0;
 		const reason = typeof body.reason === "string" ? body.reason.trim().slice(0, 160) : "";
 		if (!sessionKey || !Number.isFinite(assistantTimestamp) || assistantTimestamp <= 0 || !outcome) return c.json({ error: "sessionKey, assistantTimestamp, and a valid outcome are required" }, 400);
+		const taskOutcome = setTaskOutcomeFeedback({
+			sessionKey,
+			assistantTimestamp,
+			outcome,
+			reason: reason || void 0,
+			needsCorrection: outcome === "not_helpful",
+			...outcome === "helpful" ? { supportFit: true } : reason.includes("tone_mismatch") ? { supportFit: false } : {}
+		});
+		if (outcome === "not_helpful" && reason.includes("tone_mismatch")) setInteractionState({
+			sessionKey,
+			signal: {
+				supportNeed: "unknown",
+				confidence: 1,
+				source: "explicit",
+				repairStatus: "needed",
+				repairReason: reason
+			}
+		});
 		const trace = setLatestMemoryInjectFeedback({
 			sessionKey,
 			beforeMs: assistantTimestamp,
@@ -363,10 +391,10 @@ function registerMemoryRoutes(authenticated, deps) {
 			}
 		});
 		return c.json({
-			matched: Boolean(trace),
+			matched: Boolean(taskOutcome),
 			attributedRecordCount: trace?.selectedRecordIds.length ?? 0,
 			personalContext: personalContextForTrace(trace),
-			feedback: trace?.feedback ?? null,
+			feedback: taskOutcome?.feedback ?? null,
 			remediation: trace?.remediation ?? null
 		});
 	});
@@ -374,15 +402,16 @@ function registerMemoryRoutes(authenticated, deps) {
 		const sessionKey = c.req.query("sessionKey")?.trim() ?? "";
 		const assistantTimestamp = Number(c.req.query("assistantTimestamp"));
 		if (!sessionKey || !Number.isFinite(assistantTimestamp) || assistantTimestamp <= 0) return c.json({ error: "sessionKey and assistantTimestamp are required" }, 400);
+		const taskOutcome = findTaskOutcomeForAssistant(sessionKey, assistantTimestamp);
 		const trace = findLatestMemoryInjectTrace({
 			sessionKey,
 			beforeMs: assistantTimestamp
 		});
 		return c.json({
-			matched: Boolean(trace),
+			matched: Boolean(taskOutcome),
 			attributedRecordCount: trace?.selectedRecordIds.length ?? 0,
 			personalContext: personalContextForTrace(trace),
-			feedback: trace?.feedback ?? null
+			feedback: taskOutcome?.feedback ?? null
 		});
 	});
 	authenticated.post("/api/user-context/signals", async (c) => {

package/dist/src/gateway/hono/routes/task-outcomes.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerTaskOutcomeRoutes(authenticated: Hono, _deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/task-outcomes.js

@@ -0,0 +1,109 @@
+import { findTaskOutcomeForAssistant, getTaskOutcome, listTaskOutcomes, summarizeTaskOutcomes, updateTaskOutcome } from "../../../storage/sqlite/task-outcome-repository.js";
+import "../../../storage/sqlite/index.js";
+import { replayTaskEvaluation } from "../../../agent/outcomes/task-evaluation.js";
+//#region src/gateway/hono/routes/task-outcomes.ts
+function parseLimit(raw) {
+	if (!raw) return void 0;
+	const value = Number.parseInt(raw, 10);
+	return Number.isFinite(value) ? value : void 0;
+}
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function isTaskContract(value) {
+	if (!value || typeof value !== "object") return false;
+	const contract = value;
+	return typeof contract.objective === "string" && isStringArray(contract.deliverables) && isStringArray(contract.acceptanceCriteria) && isStringArray(contract.constraints) && isStringArray(contract.approvalRequired);
+}
+function isTaskEvidence(value) {
+	return Array.isArray(value) && value.every((item) => {
+		if (!item || typeof item !== "object") return false;
+		const evidence = item;
+		return (evidence.kind === "artifact" || evidence.kind === "test" || evidence.kind === "state" || evidence.kind === "source") && typeof evidence.title === "string" && typeof evidence.summary === "string" && (evidence.uri === void 0 || typeof evidence.uri === "string") && (evidence.verifies === void 0 || isStringArray(evidence.verifies));
+	});
+}
+function registerTaskOutcomeRoutes(authenticated, _deps) {
+	authenticated.get("/api/task-outcomes", (c) => {
+		const items = listTaskOutcomes({
+			sessionKey: c.req.query("sessionKey")?.trim() || void 0,
+			limit: parseLimit(c.req.query("limit"))
+		});
+		return c.json({
+			ok: true,
+			items
+		});
+	});
+	authenticated.get("/api/task-outcomes/metrics", (c) => {
+		return c.json({
+			ok: true,
+			metrics: summarizeTaskOutcomes()
+		});
+	});
+	authenticated.get("/api/task-outcomes/evaluation", (c) => {
+		const items = listTaskOutcomes({ limit: parseLimit(c.req.query("limit")) ?? 100 });
+		return c.json({
+			ok: true,
+			evaluation: replayTaskEvaluation(items)
+		});
+	});
+	authenticated.get("/api/task-outcomes/for-assistant", (c) => {
+		const sessionKey = c.req.query("sessionKey")?.trim() ?? "";
+		const assistantTimestamp = Number(c.req.query("assistantTimestamp"));
+		if (!sessionKey || !Number.isFinite(assistantTimestamp) || assistantTimestamp <= 0) return c.json({
+			ok: false,
+			error: "sessionKey and assistantTimestamp are required"
+		}, 400);
+		const outcome = findTaskOutcomeForAssistant(sessionKey, assistantTimestamp);
+		return outcome ? c.json({
+			ok: true,
+			outcome
+		}) : c.json({
+			ok: false,
+			error: "Task outcome not found"
+		}, 404);
+	});
+	authenticated.get("/api/task-outcomes/:runId", (c) => {
+		const outcome = getTaskOutcome(c.req.param("runId"));
+		return outcome ? c.json({
+			ok: true,
+			outcome
+		}) : c.json({
+			ok: false,
+			error: "Task outcome not found"
+		}, 404);
+	});
+	authenticated.patch("/api/task-outcomes/:runId", async (c) => {
+		const body = await c.req.json().catch(() => null);
+		if (!body || typeof body !== "object") return c.json({
+			ok: false,
+			error: "Invalid JSON body"
+		}, 400);
+		if (body.contract !== void 0 && !isTaskContract(body.contract)) return c.json({
+			ok: false,
+			error: "Invalid task contract"
+		}, 400);
+		if (body.evidence !== void 0 && !isTaskEvidence(body.evidence)) return c.json({
+			ok: false,
+			error: "Invalid task evidence"
+		}, 400);
+		if (body.summary !== void 0 && typeof body.summary !== "string") return c.json({
+			ok: false,
+			error: "Invalid task summary"
+		}, 400);
+		const outcome = updateTaskOutcome({
+			runId: c.req.param("runId"),
+			...body.contract === void 0 ? {} : { contract: body.contract },
+			...body.evidence === void 0 ? {} : { evidence: body.evidence },
+			...body.summary === void 0 ? {} : { summary: body.summary }
+		});
+		return outcome ? c.json({
+			ok: true,
+			outcome
+		}) : c.json({
+			ok: false,
+			error: "Task outcome not found"
+		}, 404);
+	});
+}
+//#endregion
+export { registerTaskOutcomeRoutes };

package/dist/src/gateway/hono/routes/you.d.ts

@@ -1,8 +1,9 @@
 import type { Hono } from 'hono';
 import type { MemoryRecord } from '../../../agent/memory/types.js';
+import { type PersonalPlaybookContext } from '../../../user-context/personal-playbook.js';
 import type { AuthenticatedRouteDeps } from './deps.js';
 export declare function buildPersonalPlaybooks(records: MemoryRecord[]): {
-    id: "communication" | "execution" | "routines";
+    id: "execution" | "communication" | "routines";
     enabled: boolean;
     rules: {
         id: string;
@@ -10,6 +11,13 @@ export declare function buildPersonalPlaybooks(records: MemoryRecord[]): {
         origin: import("../../../agent/memory/types.js").MemoryExplicitness;
         enabled: boolean;
         order: number;
+        context: PersonalPlaybookContext;
+        versions: {
+            id: string;
+            statement: string;
+            updatedAt: string;
+            current: boolean;
+        }[];
     }[];
     updatedAt: string;
 }[];
@@ -17,7 +25,7 @@ export declare function buildInsightSuggestions(records: MemoryRecord[]): {
     id: string;
     insight: string;
     kind: import("../../../agent/memory/types.js").MemoryKind;
-    action: "make_repeatable" | "start_progress";
+    action: "make_repeatable" | "add_playbook" | "start_progress";
     evidenceCount: number;
     confidence: number;
     sourceName: string;