@lumenflow/cli 3.9.5 → 3.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/cli",
-  "version": "3.9.5",
+  "version": "3.9.6",
   "description": "Command-line interface for LumenFlow workflow framework",
   "keywords": [
     "lumenflow",
@@ -180,13 +180,13 @@
     "xstate": "^5.28.0",
     "yaml": "^2.8.2",
     "zod": "^4.3.6",
-    "@lumenflow/agent": "3.9.5",
-    "@lumenflow/initiatives": "3.9.5",
-    "@lumenflow/kernel": "3.9.5",
-    "@lumenflow/memory": "3.9.5",
-    "@lumenflow/control-plane-sdk": "3.9.5",
-    "@lumenflow/metrics": "3.9.5",
-    "@lumenflow/core": "3.9.5"
+    "@lumenflow/agent": "3.9.6",
+    "@lumenflow/core": "3.9.6",
+    "@lumenflow/control-plane-sdk": "3.9.6",
+    "@lumenflow/initiatives": "3.9.6",
+    "@lumenflow/memory": "3.9.6",
+    "@lumenflow/kernel": "3.9.6",
+    "@lumenflow/metrics": "3.9.6"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^4.0.18",

package/packs/sidekick/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @lumenflow/packs-sidekick@3.9.4 build /home/tom/source/hellmai/lumenflow-dev/packages/@lumenflow/packs/sidekick
+> @lumenflow/packs-sidekick@3.9.6 build /home/runner/work/lumenflow-dev/lumenflow-dev/packages/@lumenflow/packs/sidekick
 > tsc
 

package/packs/sidekick/manifest.ts

@@ -182,9 +182,11 @@ const TOOL_INPUT_SCHEMAS: Record<SidekickToolName, Record<string, unknown>> = {
   'channel:send': {
     type: 'object',
     properties: {
+      provider: { type: 'string' },
       channel: { type: 'string' },
       content: { type: 'string', minLength: 1 },
       sender: { type: 'string' },
+      metadata: { type: 'object', additionalProperties: true },
       dry_run: { type: 'boolean' },
     },
     required: ['content'],
@@ -193,9 +195,12 @@ const TOOL_INPUT_SCHEMAS: Record<SidekickToolName, Record<string, unknown>> = {
   'channel:receive': {
     type: 'object',
     properties: {
+      provider: { type: 'string' },
       channel: { type: 'string' },
+      cursor: { type: 'string' },
       limit: { type: 'integer', minimum: 1 },
       since: { type: 'string' },
+      metadata: { type: 'object', additionalProperties: true },
     },
     additionalProperties: false,
   },

package/packs/sidekick/manifest.yaml

@@ -235,6 +235,8 @@ tools:
     input_schema:
       type: object
       properties:
+        provider:
+          type: string
         channel:
           type: string
         content:
@@ -242,6 +244,9 @@ tools:
           minLength: 1
         sender:
           type: string
+        metadata:
+          type: object
+          additionalProperties: true
         dry_run:
           type: boolean
       required: [content]
@@ -259,13 +264,20 @@ tools:
     input_schema:
       type: object
       properties:
+        provider:
+          type: string
         channel:
           type: string
+        cursor:
+          type: string
         limit:
           type: integer
           minimum: 1
         since:
           type: string
+        metadata:
+          type: object
+          additionalProperties: true
       additionalProperties: false
     output_schema:
       type: object

package/packs/sidekick/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/packs-sidekick",
-  "version": "3.9.5",
+  "version": "3.9.6",
   "description": "Sidekick personal assistant pack for LumenFlow — 16 tools for task management, typed memory, channels, routines, and audit",
   "keywords": [
     "lumenflow",
@@ -27,6 +27,7 @@
     "./storage": "./dist/tool-impl/storage.js",
     "./tools": "./dist/tools/index.js",
     "./tool-impl": "./dist/tool-impl/index.js",
+    "./tool-impl/channel-transports": "./dist/tool-impl/channel-transports.js",
     "./tool-impl/channel-tools": "./dist/tool-impl/channel-tools.js",
     "./tool-impl/memory-tools": "./dist/tool-impl/memory-tools.js",
     "./tool-impl/routine-tools": "./dist/tool-impl/routine-tools.js",

package/packs/sidekick/tool-impl/channel-tools.ts

@@ -1,6 +1,7 @@
 // Copyright (c) 2026 Hellmai Ltd
 // SPDX-License-Identifier: AGPL-3.0-only
 
+import { getChannelTransport } from './channel-transports.js';
 import { getStoragePort, type ChannelMessageRecord, type ChannelRecord } from './storage.js';
 import {
   asInteger,
@@ -29,6 +30,26 @@ const TOOL_NAMES = {
 const OUTBOX_CAP = 100;
 const DEFAULT_CHANNEL_NAME = 'default';
 
+function asOptionalRecord(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    return undefined;
+  }
+  return value as Record<string, unknown>;
+}
+
+function withTransportMetadata<T extends Record<string, unknown>>(
+  data: T,
+  metadata: Record<string, unknown> | undefined,
+): T & Record<string, unknown> {
+  if (!metadata) {
+    return data;
+  }
+  return {
+    ...data,
+    metadata,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // channel:configure
 // ---------------------------------------------------------------------------
@@ -99,6 +120,77 @@ async function channelConfigureTool(
 // channel:send
 // ---------------------------------------------------------------------------
 
+async function channelSendViaTransport(
+  input: Record<string, unknown>,
+  context: ToolContextLike | undefined,
+  provider: string,
+  channel: string,
+  content: string,
+): Promise<ToolOutput> {
+  const workspaceId = asNonEmptyString(context?.workspace_id);
+  if (!workspaceId) {
+    return failure(
+      'WORKSPACE_CONTEXT_REQUIRED',
+      'workspace_id is required when provider is specified.',
+    );
+  }
+
+  const transport = getChannelTransport(provider);
+  if (!transport) {
+    return failure(
+      'INTEGRATION_PROVIDER_NOT_REGISTERED',
+      `No channel transport registered for provider: ${provider}`,
+    );
+  }
+
+  if (isDryRun(input)) {
+    return success({
+      dry_run: true,
+      provider,
+      capability: 'send',
+      channel,
+      content,
+    });
+  }
+
+  const transportResult = await transport.send({
+    workspaceId,
+    provider,
+    channel,
+    content,
+    metadata: asOptionalRecord(input.metadata),
+  });
+
+  const outputData = withTransportMetadata(
+    {
+      provider,
+      capability: 'send',
+      channel,
+      ...(transportResult.externalMessageId !== undefined
+        ? { externalMessageId: transportResult.externalMessageId }
+        : {}),
+      ...(transportResult.failureClass ? { failureClass: transportResult.failureClass } : {}),
+      ...(transportResult.retryAfterSeconds !== undefined
+        ? { retryAfterSeconds: transportResult.retryAfterSeconds }
+        : {}),
+    },
+    transportResult.metadata,
+  );
+
+  if (!transportResult.success) {
+    return {
+      success: false,
+      error: {
+        code: 'INTEGRATION_PROVIDER_SEND_FAILED',
+        message: transportResult.error ?? `Provider send failed for provider: ${provider}`,
+      },
+      data: outputData,
+    };
+  }
+
+  return success(outputData);
+}
+
 async function channelSendTool(input: unknown, context?: ToolContextLike): Promise<ToolOutput> {
   const parsed = toRecord(input);
   const content = asNonEmptyString(parsed.content);
@@ -108,6 +200,12 @@ async function channelSendTool(input: unknown, context?: ToolContextLike): Promi
   }
 
   const channelName = asNonEmptyString(parsed.channel) ?? DEFAULT_CHANNEL_NAME;
+  const provider = asNonEmptyString(parsed.provider);
+
+  if (provider) {
+    return channelSendViaTransport(parsed, context, provider, channelName, content);
+  }
+
   const sender = asNonEmptyString(parsed.sender) ?? 'assistant';
   const now = nowIso();
 
@@ -175,10 +273,86 @@ async function channelSendTool(input: unknown, context?: ToolContextLike): Promi
 // channel:receive
 // ---------------------------------------------------------------------------
 
+async function channelReceiveViaTransport(
+  input: Record<string, unknown>,
+  context: ToolContextLike | undefined,
+  provider: string,
+  channel: string,
+  limit: number | null,
+): Promise<ToolOutput> {
+  const workspaceId = asNonEmptyString(context?.workspace_id);
+  if (!workspaceId) {
+    return failure(
+      'WORKSPACE_CONTEXT_REQUIRED',
+      'workspace_id is required when provider is specified.',
+    );
+  }
+
+  const transport = getChannelTransport(provider);
+  if (!transport) {
+    return failure(
+      'INTEGRATION_PROVIDER_NOT_REGISTERED',
+      `No channel transport registered for provider: ${provider}`,
+    );
+  }
+
+  const cursor = asNonEmptyString(input.cursor) ?? undefined;
+
+  const transportResult = await transport.receive({
+    workspaceId,
+    provider,
+    channel,
+    cursor,
+    limit: limit && limit > 0 ? limit : undefined,
+    metadata: asOptionalRecord(input.metadata),
+  });
+
+  const outputData = withTransportMetadata(
+    {
+      provider,
+      capability: 'read',
+      channel,
+      ...(transportResult.records !== undefined ? { records: transportResult.records } : {}),
+      ...(transportResult.nextCursor !== undefined
+        ? { nextCursor: transportResult.nextCursor }
+        : {}),
+      ...(transportResult.failureClass ? { failureClass: transportResult.failureClass } : {}),
+      ...(transportResult.retryAfterSeconds !== undefined
+        ? { retryAfterSeconds: transportResult.retryAfterSeconds }
+        : {}),
+    },
+    transportResult.metadata,
+  );
+
+  if (!transportResult.success) {
+    return {
+      success: false,
+      error: {
+        code: 'INTEGRATION_PROVIDER_RECEIVE_FAILED',
+        message: transportResult.error ?? `Provider receive failed for provider: ${provider}`,
+      },
+      data: outputData,
+    };
+  }
+
+  return success(outputData);
+}
+
 async function channelReceiveTool(input: unknown, _context?: ToolContextLike): Promise<ToolOutput> {
   const parsed = toRecord(input);
   const channelName = asNonEmptyString(parsed.channel);
   const limit = asInteger(parsed.limit);
+  const provider = asNonEmptyString(parsed.provider);
+
+  if (provider) {
+    return channelReceiveViaTransport(
+      parsed,
+      _context,
+      provider,
+      channelName ?? DEFAULT_CHANNEL_NAME,
+      limit,
+    );
+  }
 
   const storage = getStoragePort();
   const messages = await storage.readStore('messages');

package/packs/sidekick/tool-impl/channel-transports.ts

@@ -0,0 +1,75 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { getSidekickRuntimeContext } from './runtime-context.js';
+
+export interface ChannelTransport {
+  provider: string;
+  send(req: {
+    workspaceId: string;
+    provider: string;
+    channel: string;
+    content: string;
+    metadata?: Record<string, unknown>;
+  }): Promise<{
+    success: boolean;
+    error?: string;
+    externalMessageId?: string;
+    failureClass?: 'retryable' | 'terminal';
+    retryAfterSeconds?: number;
+    metadata?: Record<string, unknown>;
+  }>;
+  receive(req: {
+    workspaceId: string;
+    provider: string;
+    channel: string;
+    cursor?: string;
+    limit?: number;
+    metadata?: Record<string, unknown>;
+  }): Promise<{
+    success: boolean;
+    error?: string;
+    records?: unknown[];
+    nextCursor?: string;
+    failureClass?: 'retryable' | 'terminal';
+    retryAfterSeconds?: number;
+    metadata?: Record<string, unknown>;
+  }>;
+}
+
+function normalizeProvider(provider: string): string {
+  return provider.trim().toLowerCase();
+}
+
+function getRegistry(): Map<string, ChannelTransport> | undefined {
+  return getSidekickRuntimeContext()?.channelTransports;
+}
+
+export function registerChannelTransport(transport: ChannelTransport): void {
+  const provider = normalizeProvider(transport.provider);
+  if (provider.length === 0) {
+    throw new Error('channel transport provider must be a non-empty string.');
+  }
+  const registry = getRegistry();
+  if (!registry) {
+    throw new Error('channel transport registry is unavailable outside sidekick runtime context.');
+  }
+  registry.set(provider, transport);
+}
+
+export function getChannelTransport(provider: string): ChannelTransport | undefined {
+  const normalized = normalizeProvider(provider);
+  if (normalized.length === 0) {
+    return undefined;
+  }
+  const registry = getRegistry();
+  return registry?.get(normalized);
+}
+
+export function clearChannelTransports(): void {
+  const registry = getRegistry();
+  if (!registry) {
+    return;
+  }
+  registry.clear();
+}

package/packs/sidekick/tool-impl/index.ts

@@ -20,3 +20,10 @@ export {
   runWithStoragePort,
   setDefaultStoragePort,
 } from './storage.js';
+
+export {
+  type ChannelTransport,
+  clearChannelTransports,
+  getChannelTransport,
+  registerChannelTransport,
+} from './channel-transports.js';

package/packs/sidekick/tool-impl/runtime-context.ts

@@ -0,0 +1,24 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+
+import { AsyncLocalStorage } from 'node:async_hooks';
+import type { ChannelTransport } from './channel-transports.js';
+import type { StoragePort } from './storage.js';
+
+export interface SidekickRuntimeContext {
+  storagePort: StoragePort;
+  channelTransports: Map<string, ChannelTransport>;
+}
+
+const runtimeContext = new AsyncLocalStorage<SidekickRuntimeContext>();
+
+export function getSidekickRuntimeContext(): SidekickRuntimeContext | undefined {
+  return runtimeContext.getStore();
+}
+
+export async function runWithSidekickRuntimeContext<T>(
+  context: SidekickRuntimeContext,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return runtimeContext.run(context, fn);
+}

package/packs/sidekick/tool-impl/shared.ts

@@ -7,6 +7,7 @@ import type { AuditEvent } from './storage.js';
 export interface ToolContextLike {
   tool_name?: string;
   receipt_id?: string;
+  workspace_id?: string;
 }
 
 export interface ToolOutput {

package/packs/sidekick/tool-impl/storage.ts

@@ -1,10 +1,10 @@
 // Copyright (c) 2026 Hellmai Ltd
 // SPDX-License-Identifier: AGPL-3.0-only
 
-import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomBytes } from 'node:crypto';
 import { appendFile, mkdir, open, readFile, rename, rm, stat, writeFile } from 'node:fs/promises';
 import path from 'node:path';
+import { getSidekickRuntimeContext, runWithSidekickRuntimeContext } from './runtime-context.js';
 
 // ---------------------------------------------------------------------------
 // Constants
@@ -299,7 +299,6 @@ export class FsStoragePort implements StoragePort {
 // Injection helpers (AsyncLocalStorage-based)
 // ---------------------------------------------------------------------------
 
-const storageContext = new AsyncLocalStorage<StoragePort>();
 let defaultStoragePort: StoragePort = new FsStoragePort();
 
 export function setDefaultStoragePort(port: StoragePort): void {
@@ -307,9 +306,16 @@ export function setDefaultStoragePort(port: StoragePort): void {
 }
 
 export function getStoragePort(): StoragePort {
-  return storageContext.getStore() ?? defaultStoragePort;
+  return getSidekickRuntimeContext()?.storagePort ?? defaultStoragePort;
 }
 
 export async function runWithStoragePort<T>(port: StoragePort, fn: () => Promise<T>): Promise<T> {
-  return storageContext.run(port, fn);
+  const existingContext = getSidekickRuntimeContext();
+  return runWithSidekickRuntimeContext(
+    {
+      storagePort: port,
+      channelTransports: existingContext?.channelTransports ?? new Map(),
+    },
+    fn,
+  );
 }

package/packs/software-delivery/.turbo/turbo-build.log

@@ -1,4 +1,4 @@
 
-> @lumenflow/packs-software-delivery@3.9.4 build /home/tom/source/hellmai/lumenflow-dev/packages/@lumenflow/packs/software-delivery
+> @lumenflow/packs-software-delivery@3.9.6 build /home/runner/work/lumenflow-dev/lumenflow-dev/packages/@lumenflow/packs/software-delivery
 > tsc
 

package/packs/software-delivery/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumenflow/packs-software-delivery",
-  "version": "3.9.5",
+  "version": "3.9.6",
   "description": "Software delivery pack for LumenFlow — work units, gates, lanes, initiatives, and agent coordination",
   "keywords": [
     "lumenflow",