@tomflow/proflow-platform-host 0.1.28 → 0.1.30

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @tomflow/proflow-platform-host
 
+## 0.1.30
+
+### Patch Changes
+
+- Fail closed on ambiguous Task/Worker Permission identity and keep generic application-boundary observability from fabricating an authoritative side-effect state.
+
+## 0.1.29
+
+### Patch Changes
+
+- Accept real ChatGPT Custom GPT conversation URLs whose GPT path segment includes the roleRef followed by the human-readable slug, while preserving exact Worker, host, query, and hash validation for Browser Permission policy.
+
 ## 0.1.28
 
 ### Patch Changes

package/dist/deployment/adapter.d.ts

@@ -6,7 +6,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.28";
+            moduleVersion: "0.1.30";
             data: {
                 endpoint: string;
                 stateRoot: string;
@@ -24,7 +24,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-host";
-            readonly moduleVersion: "0.1.28";
+            readonly moduleVersion: "0.1.30";
         };
         observedEffects: string[];
     }>;
@@ -34,7 +34,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.28";
+            moduleVersion: "0.1.30";
             data: {
                 setupStatus: "READY";
                 runtimeStatus: "RUNNING" | "STOPPED";
@@ -48,7 +48,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.28";
+            moduleVersion: "0.1.30";
             data: {
                 endpoint: string;
                 stateRoot: string;
@@ -66,7 +66,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.28";
+            moduleVersion: "0.1.30";
             data: {
                 docs: string;
             };
@@ -79,7 +79,7 @@ export declare const behaviorAdapter: {
             ok: true;
             status: "SUCCEEDED";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.28";
+            moduleVersion: "0.1.30";
             data: {
                 host: string;
                 port: number;
@@ -90,7 +90,7 @@ export declare const behaviorAdapter: {
         result: {
             contract: "deployment.result.v1";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.28";
+            moduleVersion: "0.1.30";
             ok: false;
             status: "FAILED";
             error: {
@@ -107,7 +107,7 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-host";
-            readonly moduleVersion: "0.1.28";
+            readonly moduleVersion: "0.1.30";
         };
         observedEffects: string[];
     } | {
@@ -116,11 +116,11 @@ export declare const behaviorAdapter: {
             readonly ok: true;
             readonly status: "SUCCEEDED";
             readonly moduleRef: "platform-host";
-            readonly moduleVersion: "0.1.28";
+            readonly moduleVersion: "0.1.30";
         } | {
             contract: "deployment.result.v1";
             moduleRef: "platform-host";
-            moduleVersion: "0.1.28";
+            moduleVersion: "0.1.30";
             ok: false;
             status: "FAILED";
             error: {

package/dist/deployment/descriptor.d.ts

@@ -3,7 +3,7 @@ export declare const descriptor: {
     readonly contractVersion: "1.0.0";
     readonly moduleRef: "platform-host";
     readonly packageName: "@tomflow/proflow-platform-host";
-    readonly moduleVersion: "0.1.28";
+    readonly moduleVersion: "0.1.30";
     readonly kind: "service";
     readonly templateVersion: "1.0.0";
     readonly platformCompatibility: ">=1.0.0 <2.0.0";

package/dist/deployment/descriptor.js

@@ -3,7 +3,7 @@ export const descriptor = {
     contractVersion: "1.0.0",
     moduleRef: "platform-host",
     packageName: "@tomflow/proflow-platform-host",
-    moduleVersion: "0.1.28",
+    moduleVersion: "0.1.30",
     kind: "service",
     templateVersion: "1.0.0",
     platformCompatibility: ">=1.0.0 <2.0.0",

package/dist/src/browser-permission-context.js

@@ -21,9 +21,12 @@ export function resolveBrowserPermissionTaskBinding(input) {
                 binding.workerRef !== input.workerRef ||
                 binding.conversationLocator !== input.conversationLocator)
                 return null;
-            // The same durable Worker/Conversation may be reused by multiple Tasks.
-            // Exact duplicates strengthen the same identity; only disagreement is ambiguous.
-            match ??= binding;
+            // Worker/Conversation identity is Task-scoped. A second Task match is
+            // ambiguous even when every field is byte-identical; fail closed rather
+            // than authorizing a permission against the wrong Task occurrence.
+            if (match !== null)
+                return null;
+            match = binding;
         }
     }
     return match;

package/dist/src/browser-permission-policy.js

@@ -1,5 +1,13 @@
 import { roleOperations } from "./role-operations.js";
 const loopbackHosts = new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
+function validRoleConversationSegment(roleRef, segment) {
+    if (segment === roleRef)
+        return true;
+    if (!segment)
+        return false;
+    const slugPrefix = `${roleRef}-`;
+    return segment.startsWith(slugPrefix) && segment.length > slugPrefix.length;
+}
 function validWorkerConversation(role, context) {
     const workerRef = context.workerRef;
     if (!workerRef)
@@ -15,7 +23,7 @@ function validWorkerConversation(role, context) {
             locator.hash === "" &&
             segments.length === 4 &&
             segments[0] === "g" &&
-            segments[1] === role.roleRef &&
+            validRoleConversationSegment(role.roleRef, segments[1]) &&
             segments[2] === "c" &&
             segments[3] === workerRef);
     }

package/dist/src/index.js

@@ -1,6 +1,7 @@
+import { browserStructuredLogSchema, createOperationSink, createHostOperationObserver, operationContext, incomingOperationRef } from "./operation-observability.js";
 import { randomBytes, timingSafeEqual } from "node:crypto";
 import { existsSync } from "node:fs";
-import { appendFile, chmod, mkdir, readFile, stat, writeFile, } from "node:fs/promises";
+import { chmod, mkdir, readFile, stat, writeFile, } from "node:fs/promises";
 import { createServer } from "node:http";
 import { basename, dirname, isAbsolute, join, resolve } from "node:path";
 import { createAgentRuntime } from "@tomflow/proflow-agent-runtime";
@@ -41,32 +42,6 @@ const systemObserverReasonResultSchema = z
     rationale: z.string().min(1),
 })
     .strict();
-const browserStructuredLogSchema = z
-    .object({
-    timestamp: z.string().datetime(),
-    level: z.enum(["DEBUG", "INFO", "WARN", "ERROR"]),
-    component: z.string().min(1).max(100),
-    capability: z.string().min(1).max(160).optional(),
-    operation: z.string().min(1).max(160).optional(),
-    status: z.string().min(1).max(80).optional(),
-    errorCode: z.string().min(1).max(160).optional(),
-    correlationId: z.string().min(1).max(240).optional(),
-    taskId: z.string().min(1).max(240).optional(),
-    nodeId: z.string().min(1).max(240).optional(),
-    runNo: z.number().int().nonnegative().optional(),
-    agentPackageRef: z.string().min(1).max(240).optional(),
-    roleRef: z.string().min(1).max(240).optional(),
-    workerRef: z.string().min(1).max(240).optional(),
-    executionRef: z.string().min(1).max(240).optional(),
-    messageRef: z.string().min(1).max(240).optional(),
-    artifactRef: z.string().min(1).max(240).optional(),
-    evidenceRef: z.string().min(1).max(240).optional(),
-    conversationLocator: z.string().min(1).max(1_000).optional(),
-    operationRef: z.string().min(1).max(240).optional(),
-    attemptNo: z.number().int().nonnegative().optional(),
-    tabId: z.number().int().nonnegative().optional(),
-})
-    .strict();
 const taskDocumentFileSchema = z.object({
     taskId: z.string().min(1),
     documentType: z.string().min(1),
@@ -408,6 +383,8 @@ async function readDeploymentOwnerSummary(stateRoot) {
     }
 }
 async function constructGraph(config, executionCredential, modelCredential, resolveConnection, resolveLocalToolConnection) {
+    const sink = createOperationSink(config.stateRoot);
+    const observer = createHostOperationObserver(entry => sink.write("platform-host", entry));
     const databasePath = join(config.stateRoot, "state", "task.sqlite");
     const migration = applyMigrations({ databasePath, migrations: taskMigrations });
     if (!migration.ok)
@@ -468,8 +445,8 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         taskStore.close();
         throw error;
     }
-    const execution = createOwnerHttpClient("execution", config.executionBaseUrl, executionCredential, resolveConnection);
-    const model = createOwnerHttpClient("model", config.modelBaseUrl, modelCredential, resolveConnection);
+    const execution = observer.port("execution", createOwnerHttpClient("execution", config.executionBaseUrl, executionCredential, resolveConnection));
+    const model = observer.port("model", createOwnerHttpClient("model", config.modelBaseUrl, modelCredential, resolveConnection));
     let reconciliationCoordinator;
     const boundedSystemView = async (view) => {
         if (view === "task") {
@@ -616,7 +593,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             throw Object.assign(new Error("TASK_WORKER_BINDING_MISMATCH"), { httpStatus: 403 });
         return binding.workerRef;
     };
-    const route = async (operationId, authenticatedRoleRef, rawInput, context) => {
+    const routeImpl = async (operationId, authenticatedRoleRef, rawInput, context) => {
         const role = agent.getRegisteredRole(authenticatedRoleRef);
         if (!roleOperations[role.agentPackageRef]?.has(operationId))
             throw Object.assign(new Error("ROLE_OPERATION_DENIED"), { httpStatus: 403 });
@@ -642,7 +619,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             if (!connection)
                 throw Object.assign(new Error("LOCAL_TOOL_BRIDGE_UNAVAILABLE"), { httpStatus: 503 });
             try {
-                return await createLocalToolBridgeHostClient({
+                return await observer.run("tool-invocation", toolOperation, () => createLocalToolBridgeHostClient({
                     endpoint: connection.endpoint,
                     token: connection.credential,
                 }).request({
@@ -652,7 +629,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
                     operation: toolOperation,
                     input: toolInput,
                     deadlineAt,
-                });
+                }));
             }
             catch (error) {
                 const code = error instanceof LocalToolBridgeError
@@ -722,6 +699,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         }
         throw new Error("OPERATION_NOT_ROUTED");
     };
+    const route = (...args) => observer.run("action", args[0], () => routeImpl(...args), args[2]);
     const browserOwnerPorts = Object.freeze({
         task: Object.freeze({
             async getWorkerBinding(taskId, roleRef) {
@@ -966,7 +944,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             return null;
         }
     };
-    const roleManagement = Object.freeze({
+    const roleManagement = observer.port("role", {
         async invoke(operation, rawInput) {
             const value = object(rawInput, "role management input");
             if (operation === "role.register") {
@@ -1103,7 +1081,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         getProjection: (taskId) => taskDriverPorts.getTaskDriveProjection(taskId),
         requestWake: requestTaskWake,
     });
-    const taskApplication = Object.freeze({
+    const taskApplication = observer.port("task", {
         async invoke(operation, rawInput) {
             const value = object(rawInput, "task application input");
             if (operation === "task.create") {
@@ -1214,7 +1192,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
         });
         return context;
     };
-    const approvalApplication = Object.freeze({
+    const approvalApplication = observer.port("approval", {
         async invoke(operation, rawInput) {
             const value = object(rawInput, "approval application input");
             if (operation === "approval.list")
@@ -1258,7 +1236,7 @@ async function constructGraph(config, executionCredential, modelCredential, reso
             throw new Error("UNSUPPORTED_APPROVAL_APPLICATION_OPERATION");
         },
     });
-    const observerApplication = Object.freeze({
+    const observerApplication = observer.port("observer", {
         async invoke(operation, rawInput) {
             const value = object(rawInput, "observer application input");
             if (operation === "task.reconcileAll") {
@@ -1398,8 +1376,9 @@ async function constructGraph(config, executionCredential, modelCredential, reso
     reconciliationCoordinator.start();
     return Object.freeze({
         route,
+        operationSink: sink,
         browserOwnerPorts,
-        authorizeExecution,
+        authorizeExecution: (...args) => observer.run("execution-identity", "authorize", () => authorizeExecution(...args)),
         taskDriverPorts,
         agentIdentityPorts,
         roleManagement,
@@ -1684,7 +1663,7 @@ export function createPlatformHost(input) {
             });
             graph = await constructGraph(input.config, executionTransportCredential, modelTransportCredential, input.resolveOwnerConnection, input.resolveLocalToolConnection);
             server = createServer((request, response) => {
-                const work = (async () => {
+                const work = operationContext.run({ operationRef: incomingOperationRef(request.headers["x-proflow-operation-ref"]) }, async () => {
                     const url = new URL(request.url ?? "/", "http://platform-host.local");
                     if (request.method === "GET" && url.pathname === "/health")
                         return respond(response, 200, {
@@ -1757,10 +1736,8 @@ export function createPlatformHost(input) {
                             }
                             try {
                                 const entry = browserStructuredLogSchema.parse(JSON.parse(Buffer.concat(chunks).toString("utf8")));
-                                const logPath = join(input.config.stateRoot, "logs", "browser-extension", "events.jsonl");
-                                await mkdir(dirname(logPath), { recursive: true, mode: 0o700 });
-                                await appendFile(logPath, `${JSON.stringify({ ...entry, receivedAt: new Date().toISOString() })}\n`, { mode: 0o600 });
-                                return respond(response, 200, { accepted: true });
+                                await graph.operationSink.write("browser-extension", entry);
+                                return respond(response, 200, { accepted: true, ...(entry.eventId ? { eventId: entry.eventId } : {}) });
                             }
                             catch (error) {
                                 return respond(response, 400, {
@@ -1885,7 +1862,7 @@ export function createPlatformHost(input) {
                             error: error instanceof Error ? error.message : "INVALID_REQUEST",
                         });
                     }
-                })();
+                });
                 active.add(work);
                 void work.finally(() => active.delete(work));
             });

package/dist/src/operation-observability.d.ts

@@ -0,0 +1,73 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { z } from "zod";
+export declare const operationContext: AsyncLocalStorage<{
+    operationRef: string;
+    parentOperationRef?: string;
+}>;
+export declare function incomingOperationRef(value: unknown): string;
+export declare const browserStructuredLogSchema: z.ZodObject<{
+    timestamp: z.ZodString;
+    contract: z.ZodOptional<z.ZodLiteral<"proflow.operation-event.v1">>;
+    eventId: z.ZodOptional<z.ZodString>;
+    sequenceNo: z.ZodOptional<z.ZodNumber>;
+    source: z.ZodOptional<z.ZodLiteral<"browser-extension">>;
+    extensionInstanceId: z.ZodOptional<z.ZodString>;
+    moduleVersion: z.ZodOptional<z.ZodString>;
+    event: z.ZodOptional<z.ZodString>;
+    phase: z.ZodOptional<z.ZodString>;
+    operationId: z.ZodOptional<z.ZodString>;
+    correlationKind: z.ZodOptional<z.ZodEnum<{
+        ADJACENT: "ADJACENT";
+        EXACT: "EXACT";
+        IDENTITY_MATCH: "IDENTITY_MATCH";
+    }>>;
+    decision: z.ZodOptional<z.ZodString>;
+    reason: z.ZodOptional<z.ZodString>;
+    sideEffectState: z.ZodOptional<z.ZodEnum<{
+        APPLIED: "APPLIED";
+        NOT_APPLIED: "NOT_APPLIED";
+        NOT_STARTED: "NOT_STARTED";
+        STARTED: "STARTED";
+        UNKNOWN: "UNKNOWN";
+    }>>;
+    durationMs: z.ZodOptional<z.ZodNumber>;
+    contentInstanceId: z.ZodOptional<z.ZodString>;
+    browserSessionEpoch: z.ZodOptional<z.ZodNumber>;
+    level: z.ZodEnum<{
+        DEBUG: "DEBUG";
+        ERROR: "ERROR";
+        INFO: "INFO";
+        WARN: "WARN";
+    }>;
+    component: z.ZodString;
+    capability: z.ZodOptional<z.ZodString>;
+    operation: z.ZodOptional<z.ZodString>;
+    status: z.ZodOptional<z.ZodString>;
+    errorCode: z.ZodOptional<z.ZodString>;
+    correlationId: z.ZodOptional<z.ZodString>;
+    taskId: z.ZodOptional<z.ZodString>;
+    nodeId: z.ZodOptional<z.ZodString>;
+    runNo: z.ZodOptional<z.ZodNumber>;
+    agentPackageRef: z.ZodOptional<z.ZodString>;
+    roleRef: z.ZodOptional<z.ZodString>;
+    workerRef: z.ZodOptional<z.ZodString>;
+    executionRef: z.ZodOptional<z.ZodString>;
+    messageRef: z.ZodOptional<z.ZodString>;
+    artifactRef: z.ZodOptional<z.ZodString>;
+    evidenceRef: z.ZodOptional<z.ZodString>;
+    conversationLocator: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>>;
+    operationRef: z.ZodOptional<z.ZodString>;
+    attemptNo: z.ZodOptional<z.ZodNumber>;
+    tabId: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+/** One Host append owner, bounded queue and two 5 MiB segments per source. */
+export declare function createOperationSink(stateRoot: string): {
+    write: (source: "browser-extension" | "platform-host", entry: Record<string, unknown>) => Promise<void>;
+    drain: () => Promise<void>;
+};
+export declare function createHostOperationObserver(emit: (entry: Record<string, unknown>) => unknown): {
+    run: <T>(surface: string, operationId: string, invoke: () => Promise<T>, axesInput?: unknown) => Promise<T>;
+    port: <T extends {
+        invoke(operation: string, input: unknown): Promise<unknown>;
+    }>(surface: string, target: T) => T;
+};

package/dist/src/operation-observability.js

@@ -0,0 +1,235 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { randomUUID } from "node:crypto";
+import { appendFile, mkdir, open, stat, rename, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { z } from "zod";
+const safeRef = z.string().regex(/^[A-Za-z0-9_.:@/><-]{1,240}$/);
+function sanitizeUrl(value) {
+    try {
+        const url = new URL(value);
+        if (!["http:", "https:"].includes(url.protocol))
+            return "[REDACTED_INVALID_LOCATOR]";
+        url.username = "";
+        url.password = "";
+        url.search = "";
+        url.hash = "";
+        return url.toString();
+    }
+    catch {
+        return "[REDACTED_INVALID_LOCATOR]";
+    }
+}
+async function retainedTail(path) {
+    const file = await open(path, "r");
+    try {
+        const size = (await file.stat()).size;
+        const start = Math.max(0, size - 5 * 1024 * 1024);
+        const buffer = Buffer.alloc(size - start);
+        await file.read(buffer, 0, buffer.length, start);
+        const text = buffer.toString("utf8");
+        return start ? text.slice(text.indexOf("\n") + 1) : text;
+    }
+    finally {
+        await file.close();
+    }
+}
+export const operationContext = new AsyncLocalStorage();
+export function incomingOperationRef(value) {
+    return typeof value === "string" && /^op:[0-9a-f-]{36}$/.test(value)
+        ? value
+        : `op:${randomUUID()}`;
+}
+export const browserStructuredLogSchema = z
+    .object({
+    timestamp: z.string().datetime(),
+    contract: z.literal("proflow.operation-event.v1").optional(),
+    eventId: safeRef.optional(),
+    sequenceNo: z.number().int().nonnegative().optional(),
+    source: z.literal("browser-extension").optional(),
+    extensionInstanceId: safeRef.optional(),
+    moduleVersion: safeRef.optional(),
+    event: safeRef.optional(),
+    phase: safeRef.optional(),
+    operationId: safeRef.optional(),
+    correlationKind: z.enum(["EXACT", "IDENTITY_MATCH", "ADJACENT"]).optional(),
+    decision: safeRef.optional(),
+    reason: safeRef.optional(),
+    sideEffectState: z
+        .enum(["NOT_STARTED", "STARTED", "APPLIED", "NOT_APPLIED", "UNKNOWN"])
+        .optional(),
+    durationMs: z.number().nonnegative().optional(),
+    contentInstanceId: safeRef.optional(),
+    browserSessionEpoch: z.number().int().nonnegative().optional(),
+    level: z.enum(["DEBUG", "INFO", "WARN", "ERROR"]),
+    component: safeRef,
+    capability: safeRef.optional(),
+    operation: safeRef.optional(),
+    status: safeRef.optional(),
+    errorCode: safeRef.optional(),
+    correlationId: safeRef.optional(),
+    taskId: safeRef.optional(),
+    nodeId: safeRef.optional(),
+    runNo: z.number().int().nonnegative().optional(),
+    agentPackageRef: safeRef.optional(),
+    roleRef: safeRef.optional(),
+    workerRef: safeRef.optional(),
+    executionRef: safeRef.optional(),
+    messageRef: safeRef.optional(),
+    artifactRef: safeRef.optional(),
+    evidenceRef: safeRef.optional(),
+    conversationLocator: z
+        .string()
+        .max(1_000)
+        .transform(sanitizeUrl)
+        .optional(),
+    operationRef: safeRef.optional(),
+    attemptNo: z.number().int().nonnegative().optional(),
+    tabId: z.number().int().nonnegative().optional(),
+})
+    .strict();
+/** One Host append owner, bounded queue and two 5 MiB segments per source. */
+export function createOperationSink(stateRoot) {
+    let tail = Promise.resolve();
+    let pending = 0;
+    const seen = new Set();
+    let restored = false;
+    const write = (source, entry) => {
+        if (pending >= 1000)
+            return Promise.reject(new Error("LOG_QUEUE_FULL"));
+        pending++;
+        const run = tail.then(async () => {
+            const path = join(stateRoot, "logs", source, "events.jsonl");
+            await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+            if (source === "browser-extension" && !restored) {
+                for (const file of [path + ".1", path]) {
+                    try {
+                        for (const line of (await retainedTail(file)).split("\n")) {
+                            try {
+                                const v = JSON.parse(line);
+                                if (v &&
+                                    typeof v === "object" &&
+                                    typeof Reflect.get(v, "eventId") === "string")
+                                    seen.add(String(Reflect.get(v, "eventId")));
+                                if (seen.size > 20000)
+                                    seen.delete(seen.values().next().value ?? "");
+                            }
+                            catch { }
+                        }
+                    }
+                    catch { }
+                }
+                restored = true;
+            }
+            const eventId = typeof entry.eventId === "string" ? entry.eventId : undefined;
+            if (eventId && seen.has(eventId))
+                return;
+            const info = await stat(path).catch(() => null);
+            if (info &&
+                (info.size >= 5 * 1024 * 1024 ||
+                    Date.now() - info.mtimeMs > 7 * 86400_000))
+                await rename(path, path + ".1");
+            await appendFile(path, JSON.stringify({ ...entry, receivedAt: new Date().toISOString() }) +
+                "\n", { mode: 0o600 });
+            if (eventId) {
+                seen.add(eventId);
+                if (seen.size > 20000)
+                    seen.delete(seen.values().next().value ?? "");
+            }
+        });
+        tail = run
+            .catch(() => undefined)
+            .finally(() => {
+            pending--;
+        });
+        return run;
+    };
+    return { write, drain: () => tail };
+}
+function code(value) {
+    return typeof value === "string" && /^[A-Z][A-Z0-9_.:-]{0,159}$/.test(value)
+        ? value
+        : undefined;
+}
+export function createHostOperationObserver(emit) {
+    const run = async (surface, operationId, invoke, axesInput) => {
+        const parent = operationContext.getStore();
+        const operationRef = `op:${randomUUID()}`;
+        const started = performance.now();
+        const record = (value, error) => {
+            const axes = {};
+            for (const candidate of [axesInput, value]) {
+                if (!candidate || typeof candidate !== "object")
+                    continue;
+                for (const key of ["taskId", "nodeId", "executionRef", "workerRef", "roleRef", "evidenceRef", "artifactRef"]) {
+                    const v = Reflect.get(candidate, key);
+                    if (safeRef.safeParse(v).success)
+                        axes[key] = String(v);
+                }
+            }
+            const result = value && typeof value === "object" ? value : {};
+            const failed = error !== undefined || Reflect.get(result, "ok") === false;
+            const errorValue = error ?? Reflect.get(result, "error");
+            const errorCode = errorValue && typeof errorValue === "object"
+                ? code(Reflect.get(errorValue, "code")) ?? code(Reflect.get(errorValue, "message"))
+                : undefined;
+            const sideEffectState = Reflect.get(result, "sideEffectState");
+            const hasAuthoritativeSideEffectState = typeof sideEffectState === "string" &&
+                ["NOT_STARTED", "STARTED", "APPLIED", "NOT_APPLIED", "UNKNOWN"].includes(sideEffectState);
+            const entry = {
+                contract: "proflow.operation-boundary.v1",
+                eventId: `host-event:${randomUUID()}`,
+                timestamp: new Date().toISOString(),
+                source: "platform-host",
+                component: "platform-host-application-boundary",
+                event: "HOST_APPLICATION",
+                phase: surface,
+                operationId: safeRef.safeParse(operationId).success
+                    ? operationId
+                    : "INVALID_OPERATION",
+                operationRef,
+                ...(parent
+                    ? {
+                        parentOperationRef: parent.operationRef,
+                        correlationId: parent.parentOperationRef ?? parent.operationRef,
+                    }
+                    : {}),
+                correlationKind: "EXACT",
+                ...axes,
+                decision: code(Reflect.get(result, "decision")), reason: code(Reflect.get(result, "reason")),
+                status: failed ? "FAILED" : Reflect.get(result, "decision") === "HUMAN_REQUIRED" ? "BLOCKED" : Reflect.get(result, "decision") === "DEFER" ? "DEFERRED" : "SUCCEEDED",
+                ...(hasAuthoritativeSideEffectState ? { sideEffectState } : {}),
+                ...(failed
+                    ? { errorCode: errorCode ?? "HOST_APPLICATION_FAILED" }
+                    : {}),
+                durationMs: performance.now() - started,
+            };
+            try {
+                void Promise.resolve(emit(entry)).catch(() => undefined);
+            }
+            catch { }
+        };
+        return operationContext.run({
+            operationRef,
+            ...(parent
+                ? {
+                    parentOperationRef: parent.parentOperationRef ?? parent.operationRef,
+                }
+                : {}),
+        }, async () => {
+            try {
+                const value = await invoke();
+                record(value);
+                return value;
+            }
+            catch (error) {
+                record(undefined, error);
+                throw error;
+            }
+        });
+    };
+    const port = (surface, target) => Object.freeze({
+        ...target,
+        invoke: (operation, input) => run(surface, operation, () => target.invoke(operation, input), input),
+    });
+    return { run, port };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tomflow/proflow-platform-host",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -24,19 +24,19 @@
   ],
   "dependencies": {
     "zod": "4.1.12",
-    "@tomflow/proflow-agent-runtime": "^0.1.17",
-    "@tomflow/proflow-task-orchestration": "^0.1.11",
+    "@tomflow/proflow-execution-browser-extension": "^0.1.62",
     "@tomflow/proflow-task-migration-runner": "^0.1.11",
+    "@tomflow/proflow-task-orchestration": "^0.1.11",
     "@tomflow/proflow-task-store-sqlite": "^0.1.12",
-    "@tomflow/proflow-execution-contracts": "^0.1.11",
+    "@tomflow/proflow-agent-runtime": "^0.1.17",
     "@tomflow/proflow-module-contract": "^0.1.13",
-    "@tomflow/proflow-execution-browser-extension": "^0.1.58"
+    "@tomflow/proflow-execution-contracts": "^0.1.11"
   },
   "devDependencies": {
     "@tomflow/proflow-deployment-conformance": "^0.1.13",
-    "@tomflow/proflow-agent-gateway": "^0.1.18",
+    "@tomflow/proflow-execution-runtime": "^0.1.19",
     "@tomflow/proflow-model-runtime": "^0.1.25",
-    "@tomflow/proflow-execution-runtime": "^0.1.19"
+    "@tomflow/proflow-agent-gateway": "^0.1.18"
   },
   "description": "Provides the ProFlow local application composition root that binds Task, Agent, Execution and Model owner transports.",
   "keywords": [

package/proflow.module.json

@@ -3,7 +3,7 @@
 	"contractVersion": "1.0.0",
 	"moduleRef": "platform-host",
 	"packageName": "@tomflow/proflow-platform-host",
-	"moduleVersion": "0.1.28",
+	"moduleVersion": "0.1.30",
 	"kind": "service",
 	"templateVersion": "1.0.0",
 	"platformCompatibility": ">=1.0.0 <2.0.0",