@ultrst-armada/kloks 1.6.0 → 1.7.0

package/packages/backend/dist/{chunk-3HZYAZF4.js → chunk-SQGBAWZN.js}

@@ -245,6 +245,7 @@ var DevelopmentServiceDefinition = createServiceDefinition({
         providers: [
           { id: "webcontainer", capabilities: ["install", "lint", "test", "build", "validate", "check", "process-host"] },
           { id: "typescript-language-server", capabilities: ["lsp", "diagnostics", "completion", "hover", "definition", "references", "rename", "symbols"] },
+          { id: "agent-harness", capabilities: ["deepseek", "openai", "google", "headless", "sdk", "acp"] },
           { id: "github-actions", capabilities: ["dispatch", "observe", "rerun", "cancel"] }
         ]
       })
@@ -301,8 +302,8 @@ var COMMANDS2 = {
 var DEFAULT_LAYERS = ["syntax", "lint", "krnl", "frnl"];
 var commandText = (command, args) => [command, ...args].join(" ");
 var CodeValidationRuntime = class {
-  constructor(runtime4 = new WebContainerRuntime()) {
-    this.runtime = runtime4;
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
   }
   runtime;
   async validate(input = {}) {
@@ -356,8 +357,8 @@ var CodeValidationServiceFacade = {
 
 // src/development/codeDiagnosticsService.ts
 var CodeDiagnosticsService = class {
-  constructor(runtime4 = new WebContainerRuntime()) {
-    this.runtime = runtime4;
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
   }
   runtime;
   async diagnostics(input = {}) {
@@ -375,8 +376,8 @@ var TYPESCRIPT_LANGUAGE_SERVER_VERSION = "6.0.2";
 var PACKAGE = TYPESCRIPT_LANGUAGE_SERVER_PACKAGE;
 var DEFAULT_VERSION = TYPESCRIPT_LANGUAGE_SERVER_VERSION;
 var TypeScriptLanguageServerRuntime = class {
-  constructor(runtime4 = new WebContainerRuntime()) {
-    this.runtime = runtime4;
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
   }
   runtime;
   process = null;
@@ -502,6 +503,92 @@ var TypeScriptLanguageServerServiceFacade = {
   }
 };
 
+// src/development/agentHarnessService.ts
+var PROVIDERS = [
+  {
+    id: "deepseek",
+    name: "DeepSeek Harness",
+    package: "@deepseek-ai/dsh",
+    capabilities: ["headless", "sdk", "acp", "web"],
+    implemented: true
+  },
+  {
+    id: "openai",
+    name: "OpenAI Agents SDK",
+    package: "@openai/agents",
+    capabilities: ["agents", "tools", "handoffs", "guardrails", "sessions", "tracing"],
+    implemented: false
+  },
+  {
+    id: "google",
+    name: "Google ADK",
+    package: "@google/adk",
+    capabilities: ["agents", "tools", "multi-agent", "evaluation", "deployment"],
+    implemented: false
+  }
+];
+var AgentHarnessRuntime = class {
+  constructor(runtime5 = new WebContainerRuntime()) {
+    this.runtime = runtime5;
+  }
+  runtime;
+  providers() {
+    return PROVIDERS.map((provider) => ({ ...provider, capabilities: [...provider.capabilities] }));
+  }
+  async run(input) {
+    if (input.provider !== "deepseek") {
+      throw new Error(
+        `Agent harness provider "${input.provider}" is registered but not yet executable; install and register its adapter before running it.`
+      );
+    }
+    const started = Date.now();
+    const profile = input.profile ?? "headless";
+    const command = "pnpm";
+    const args = ["exec", "dsh", "--profile", profile, input.prompt];
+    const result = await this.runtime.runCommand(command, args, input.cwd ?? ".", input.env);
+    return {
+      provider: input.provider,
+      ok: result.exitCode === 0,
+      exitCode: result.exitCode,
+      output: result.output,
+      durationMs: Date.now() - started,
+      command: [command, ...args].join(" ")
+    };
+  }
+};
+var runtime4 = new AgentHarnessRuntime();
+var AgentHarnessServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.agentHarness",
+  name: "AgentHarnessService",
+  version: "1.0.0",
+  operations: {
+    providers: {
+      id: "AgentHarnessService.providers",
+      name: "providers",
+      handler: async () => runtime4.providers()
+    },
+    run: {
+      id: "AgentHarnessService.run",
+      name: "run",
+      handler: async (input) => runtime4.run(input)
+    }
+  }
+});
+var AgentHarnessServiceFacade = {
+  id: AgentHarnessServiceDefinition.id,
+  name: AgentHarnessServiceDefinition.name,
+  version: AgentHarnessServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: AgentHarnessServiceDefinition,
+  createInstance: () => createService(AgentHarnessServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(AgentHarnessServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
 export {
   GitHubActionsClient,
   GitHubActionsServiceDefinition,
@@ -521,5 +608,8 @@ export {
   TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
   TYPESCRIPT_LANGUAGE_SERVER_VERSION,
   TypeScriptLanguageServerServiceDefinition,
-  TypeScriptLanguageServerServiceFacade
+  TypeScriptLanguageServerServiceFacade,
+  AgentHarnessRuntime,
+  AgentHarnessServiceDefinition,
+  AgentHarnessServiceFacade
 };

package/packages/backend/dist/chunk-VAFCR2MS.js

@@ -0,0 +1,203 @@
+// src/core/unifiedDb.ts
+var neon;
+function cleanDbUrl(url) {
+  if (!url || typeof url !== "string") return "";
+  return url.trim().replace(/^["']|["']$/g, "");
+}
+function getUnifiedDbUrl(env) {
+  const fromEnv = cleanDbUrl(env?.SYSTEM_DATABASE_URL_1) || cleanDbUrl(env?.DATABASE_URL) || cleanDbUrl(env?.SYSTEM_DATABASE_URL_2);
+  if (fromEnv) return fromEnv;
+  if (typeof process !== "undefined" && process.env) {
+    return cleanDbUrl(process.env.SYSTEM_DATABASE_URL_1) || cleanDbUrl(process.env.DATABASE_URL) || cleanDbUrl(process.env.SYSTEM_DATABASE_URL_2) || cleanDbUrl(process.env.SYSTEM_DATABASE_URL_3) || "";
+  }
+  return "";
+}
+async function queryUnifiedDb(sqlText, params = [], env) {
+  const dbUrl = getUnifiedDbUrl(env);
+  if (!dbUrl) {
+    throw new Error("[UnifiedDB] No database URL configured in environment.");
+  }
+  if (!neon) {
+    const mod = await import("@neondatabase/serverless");
+    neon = mod.neon;
+  }
+  const sql = neon(dbUrl);
+  try {
+    const rows = await (sql.query ? sql.query(sqlText, params) : sql(sqlText, params));
+    return {
+      rows: Array.isArray(rows) ? rows : [],
+      rowCount: Array.isArray(rows) ? rows.length : 0
+    };
+  } catch (err) {
+    console.error("[UnifiedDB] Query execution error:", err.message);
+    throw err;
+  }
+}
+
+// src/core/b2DirectCore.ts
+var authCache = /* @__PURE__ */ new Map();
+var bucketIdCache = /* @__PURE__ */ new Map();
+async function authorizeB2(keyId, applicationKey) {
+  const cacheKey = `${keyId.trim()}:${applicationKey.trim()}`;
+  const cached = authCache.get(cacheKey);
+  if (cached && Date.now() < cached.expiresAt) return cached.auth;
+  const authHeader = typeof Buffer !== "undefined" ? Buffer.from(`${keyId.trim()}:${applicationKey.trim()}`).toString("base64") : btoa(`${keyId.trim()}:${applicationKey.trim()}`);
+  let res = await fetch("https://api.backblazeb2.com/b2api/v2/b2_authorize_account", {
+    headers: { Authorization: `Basic ${authHeader}` },
+    signal: AbortSignal.timeout(1e4)
+  });
+  if (!res.ok) {
+    res = await fetch("https://api.backblazeb2.com/b2api/v4/b2_authorize_account", {
+      headers: { Authorization: `Basic ${authHeader}` },
+      signal: AbortSignal.timeout(1e4)
+    });
+  }
+  if (!res.ok) {
+    const errText = await res.text();
+    throw new Error(`Backblaze B2 authorization failed (${res.status}): ${errText}`);
+  }
+  const data = await res.json();
+  const auth = {
+    accountId: data.accountId,
+    authorizationToken: data.authorizationToken,
+    apiUrl: (data.apiInfo?.storageApi?.apiUrl || data.apiUrl || "https://api.backblazeb2.com").replace(/\/+$/, ""),
+    downloadUrl: (data.apiInfo?.storageApi?.downloadUrl || data.downloadUrl || data.apiUrl || "https://f003.backblazeb2.com").replace(/\/+$/, ""),
+    s3ApiUrl: data.apiInfo?.storageApi?.s3ApiUrl || data.s3ApiUrl,
+    allowed: data.apiInfo?.storageApi?.allowed || data.allowed
+  };
+  authCache.set(cacheKey, { auth, expiresAt: Date.now() + 20 * 60 * 1e3 });
+  return auth;
+}
+async function b2ListBuckets(keyId, applicationKey, bucketId, bucketName) {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const rBucketId = bucketId || auth.allowed?.bucketId || auth.allowed?.buckets?.[0]?.bucketId;
+  const rBucketName = bucketName || auth.allowed?.bucketName || auth.allowed?.buckets?.[0]?.bucketName;
+  if (!auth.allowed?.bucketId && !auth.allowed?.bucketName) {
+    try {
+      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
+        method: "POST",
+        headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+        body: JSON.stringify({ accountId: auth.accountId }),
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (Array.isArray(data.buckets) && data.buckets.length > 0) return data.buckets;
+      }
+    } catch (err) {
+      console.warn("[B2DirectCore] list_buckets query failed:", err.message);
+    }
+  }
+  if (rBucketId || rBucketName) {
+    const body = { accountId: auth.accountId };
+    if (rBucketId) body.bucketId = rBucketId;
+    else if (rBucketName) body.bucketName = rBucketName;
+    try {
+      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
+        method: "POST",
+        headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(8e3)
+      });
+      if (res.ok) {
+        const data = await res.json();
+        if (Array.isArray(data.buckets) && data.buckets.length > 0) return data.buckets;
+      }
+    } catch {
+    }
+    return [{
+      accountId: auth.accountId,
+      bucketId: rBucketId || "restricted",
+      bucketName: rBucketName || (bucketName || "default-bucket"),
+      bucketType: "allPrivate"
+    }];
+  }
+  return [];
+}
+async function getB2BucketId(keyId, applicationKey, bucketName) {
+  const cacheKey = `${keyId.trim()}:${bucketName.trim()}`;
+  if (bucketIdCache.has(cacheKey)) return bucketIdCache.get(cacheKey);
+  const buckets = await b2ListBuckets(keyId, applicationKey, void 0, bucketName);
+  const match = buckets.find((b) => b.bucketName === bucketName);
+  if (!match) throw new Error(`B2 bucket "${bucketName}" not found in account`);
+  bucketIdCache.set(cacheKey, match.bucketId);
+  return match.bucketId;
+}
+async function b2UploadFile(keyId, applicationKey, bucketName, fileName, buffer, contentType = "b2/x-auto") {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const bucketId = await getB2BucketId(keyId, applicationKey, bucketName);
+  const urlRes = await fetch(`${auth.apiUrl}/b2api/v2/b2_get_upload_url`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ bucketId })
+  });
+  if (!urlRes.ok) throw new Error(`B2 get upload url failed (${urlRes.status})`);
+  const { uploadUrl, authorizationToken } = await urlRes.json();
+  const encodedFileName = encodeURIComponent(fileName).replace(/%2F/g, "/");
+  const uploadRes = await fetch(uploadUrl, {
+    method: "POST",
+    headers: {
+      Authorization: authorizationToken,
+      "X-Bz-File-Name": encodedFileName,
+      "Content-Type": contentType,
+      "Content-Length": String(buffer.byteLength),
+      "X-Bz-Content-Sha1": "do_not_verify"
+    },
+    body: buffer
+  });
+  if (!uploadRes.ok) throw new Error(`B2 upload failed for ${fileName} (${uploadRes.status}): ${await uploadRes.text()}`);
+  return uploadRes.json();
+}
+async function b2DownloadFile(keyId, applicationKey, bucketName, fileName) {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const encodedName = encodeURIComponent(fileName).replace(/%2F/g, "/");
+  const res = await fetch(`${auth.downloadUrl}/file/${bucketName}/${encodedName}`, { headers: { Authorization: auth.authorizationToken } });
+  if (res.status === 404) return null;
+  if (!res.ok) throw new Error(`B2 download failed for ${fileName} (${res.status})`);
+  return new Uint8Array(await res.arrayBuffer());
+}
+async function b2ListFileNames(keyId, applicationKey, bucketName, prefix = "") {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const bucketId = await getB2BucketId(keyId, applicationKey, bucketName);
+  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_file_names`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ bucketId, prefix, maxFileCount: 1e3 })
+  });
+  if (!res.ok) throw new Error(`B2 list files failed (${res.status})`);
+  const data = await res.json();
+  return data.files || [];
+}
+async function b2DeleteFileVersion(keyId, applicationKey, fileName, fileId) {
+  const auth = await authorizeB2(keyId, applicationKey);
+  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_delete_file_version`, {
+    method: "POST",
+    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
+    body: JSON.stringify({ fileName, fileId })
+  });
+  if (!res.ok) throw new Error(`B2 delete file version failed (${res.status})`);
+  return res.json();
+}
+async function b2DeleteFolder(keyId, applicationKey, bucketName, folderPrefix) {
+  const cleanPrefix = folderPrefix.replace(/\/+$/, "") + "/";
+  const files = await b2ListFileNames(keyId, applicationKey, bucketName, cleanPrefix);
+  let deletedCount = 0;
+  for (const file of files) {
+    await b2DeleteFileVersion(keyId, applicationKey, file.fileName, file.fileId);
+    deletedCount++;
+  }
+  return { success: true, deletedCount };
+}
+
+export {
+  cleanDbUrl,
+  getUnifiedDbUrl,
+  queryUnifiedDb,
+  b2ListBuckets,
+  getB2BucketId,
+  b2UploadFile,
+  b2DownloadFile,
+  b2ListFileNames,
+  b2DeleteFileVersion,
+  b2DeleteFolder
+};

package/packages/backend/dist/{chunk-GQUNN7SA.js → chunk-Y3X3H2XX.js}

@@ -1,10 +1,10 @@
 import {
   workspaceGraphService
-} from "./chunk-DBZVGMJ7.js";
+} from "./chunk-KSZ67VZJ.js";
 import {
   getSrklAccounts,
   srklListBackblazeBuckets
-} from "./chunk-VDROUXFT.js";
+} from "./chunk-N4Z57FVR.js";
 import {
   StorageAdapterFactory
 } from "./chunk-J2J24JVC.js";
@@ -20,9 +20,11 @@ import {
   deleteWorkspace,
   findUserWorkspace,
   getWorkspaces,
-  queryUnifiedDb,
   updateWorkspace
-} from "./chunk-E72GXBXF.js";
+} from "./chunk-6K75XXFD.js";
+import {
+  queryUnifiedDb
+} from "./chunk-VAFCR2MS.js";
 import {
   RateLimiter,
   SessionManager,

package/packages/backend/dist/development/index.d.ts

@@ -245,4 +245,57 @@ declare const TypeScriptLanguageServerServiceFacade: {
     execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
 };
 
-export { type CodeDiagnosticsInput, type CodeDiagnosticsResult, CodeDiagnosticsService, type CodeValidationInput, type CodeValidationResult, CodeValidationRuntime, CodeValidationServiceDefinition, CodeValidationServiceFacade, type DevelopmentProvider, type DevelopmentRequest, type DevelopmentResult, DevelopmentRuntime, type DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, type DevelopmentTask, GitHubActionsClient, type GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, TYPESCRIPT_LANGUAGE_SERVER_PACKAGE, TYPESCRIPT_LANGUAGE_SERVER_VERSION, type TypeScriptLanguageServerNotificationInput, type TypeScriptLanguageServerRequestInput, type TypeScriptLanguageServerResponse, TypeScriptLanguageServerServiceDefinition, TypeScriptLanguageServerServiceFacade, type TypeScriptLanguageServerStartInput, type TypeScriptLanguageServerStatus, type ValidationDiagnostic, type ValidationLayer, type WebContainerCommand, type WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, type WorkflowRun, codeDiagnosticsService, resolveDevelopmentCommand };
+type AgentHarnessProvider = 'deepseek' | 'openai' | 'google';
+interface AgentHarnessRunInput {
+    provider: AgentHarnessProvider;
+    prompt: string;
+    cwd?: string;
+    profile?: string;
+    timeoutMs?: number;
+    env?: Record<string, string>;
+}
+interface AgentHarnessResult {
+    provider: AgentHarnessProvider;
+    ok: boolean;
+    exitCode: number;
+    output: string;
+    durationMs: number;
+    command?: string;
+}
+interface AgentHarnessProviderInfo {
+    id: AgentHarnessProvider;
+    name: string;
+    package: string;
+    capabilities: string[];
+    implemented: boolean;
+}
+interface AgentHarnessServiceContract {
+    providers(): AgentHarnessProviderInfo[];
+    run(input: AgentHarnessRunInput): Promise<AgentHarnessResult>;
+}
+
+declare class AgentHarnessRuntime {
+    private readonly runtime;
+    constructor(runtime?: WebContainerRuntime);
+    providers(): {
+        capabilities: string[];
+        id: AgentHarnessProvider;
+        name: string;
+        package: string;
+        implemented: boolean;
+    }[];
+    run(input: AgentHarnessRunInput): Promise<AgentHarnessResult>;
+}
+declare const AgentHarnessServiceDefinition: ServiceDefinition;
+declare const AgentHarnessServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "client";
+    deployment: "local";
+    definition: ServiceDefinition<Record<string, unknown>, Record<string, unknown>>;
+    createInstance: () => _ultrst_armada_krnl.ServiceInstance<Record<string, unknown>, Record<string, unknown>>;
+    execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
+};
+
+export { type AgentHarnessProvider, type AgentHarnessProviderInfo, type AgentHarnessResult, type AgentHarnessRunInput, AgentHarnessRuntime, type AgentHarnessServiceContract, AgentHarnessServiceDefinition, AgentHarnessServiceFacade, type CodeDiagnosticsInput, type CodeDiagnosticsResult, CodeDiagnosticsService, type CodeValidationInput, type CodeValidationResult, CodeValidationRuntime, CodeValidationServiceDefinition, CodeValidationServiceFacade, type DevelopmentProvider, type DevelopmentRequest, type DevelopmentResult, DevelopmentRuntime, type DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, type DevelopmentTask, GitHubActionsClient, type GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, TYPESCRIPT_LANGUAGE_SERVER_PACKAGE, TYPESCRIPT_LANGUAGE_SERVER_VERSION, type TypeScriptLanguageServerNotificationInput, type TypeScriptLanguageServerRequestInput, type TypeScriptLanguageServerResponse, TypeScriptLanguageServerServiceDefinition, TypeScriptLanguageServerServiceFacade, type TypeScriptLanguageServerStartInput, type TypeScriptLanguageServerStatus, type ValidationDiagnostic, type ValidationLayer, type WebContainerCommand, type WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, type WorkflowRun, codeDiagnosticsService, resolveDevelopmentCommand };

package/packages/backend/dist/development/index.js

@@ -1,4 +1,7 @@
 import {
+  AgentHarnessRuntime,
+  AgentHarnessServiceDefinition,
+  AgentHarnessServiceFacade,
   CodeDiagnosticsService,
   CodeValidationRuntime,
   CodeValidationServiceDefinition,
@@ -18,9 +21,12 @@ import {
   WebContainerServiceFacade,
   codeDiagnosticsService,
   resolveDevelopmentCommand
-} from "../chunk-3HZYAZF4.js";
+} from "../chunk-SQGBAWZN.js";
 import "../chunk-TY32TUNI.js";
 export {
+  AgentHarnessRuntime,
+  AgentHarnessServiceDefinition,
+  AgentHarnessServiceFacade,
   CodeDiagnosticsService,
   CodeValidationRuntime,
   CodeValidationServiceDefinition,

package/packages/backend/dist/index.d.ts

@@ -13,7 +13,7 @@ export { AdaptedStorageConnection, AppAccountManifest, AppServiceDeclaration, CA
 export { CompositeBackend, EndpointGenerator, GeneratedEndpointSummary, LOCAL_STORAGE_GRAPHS_PREFIX, LocalService, NodeGraphPersistenceService, NodeGraphValidationResult, RemoteServiceProxy, SaveGraphOptions, UniversalAppEntity, UniversalGraphEdge, UniversalGraphNode, UniversalNodeGraphDocument, UniversalStorageConnection, WorkspaceGraphDocument, WorkspaceGraphSummary, createBackend, createCompositeService, createLocalService, createRemoteService, exportGraphAsJsonFile, nodeGraphPersistence, parseGraphJsonFile, validateGraphDocument, workspaceGraphService } from './services/index.js';
 import { AssetDataType as AssetDataType$1, AssetChannelType as AssetChannelType$1, GraphFolderInfo as GraphFolderInfo$1, GraphAssetItem as GraphAssetItem$1, SpaceNode, NodeConnection, DawProject } from '@ultrst-armada/kloks/state-graph';
 export { AuthServiceDefinition, AuthServiceFacade, ControlPlaneServiceDefinition, ControlPlaneServiceFacade, DatabaseServiceDefinition, DatabaseServiceFacade, GeminiServiceDefinition, GeminiServiceFacade, SrklServiceDefinition, SrklServiceFacade, StorageServiceDefinition, StorageServiceFacade, WorkspaceGraphServiceDefinition, WorkspaceGraphServiceFacade, WorkspaceServiceDefinition, WorkspaceServiceFacade, krnlAuthServiceDefinition, krnlAuthServiceFacade, krnlControlPlaneServiceDefinition, krnlControlPlaneServiceFacade, krnlDatabaseServiceDefinition, krnlDatabaseServiceFacade, krnlGeminiServiceDefinition, krnlGeminiServiceFacade, krnlSrklServiceDefinition, krnlSrklServiceFacade, krnlStorageServiceDefinition, krnlStorageServiceFacade, krnlWorkspaceGraphServiceDefinition, krnlWorkspaceGraphServiceFacade, krnlWorkspaceServiceDefinition, krnlWorkspaceServiceFacade } from './krnl-services.js';
-export { CodeDiagnosticsInput, CodeDiagnosticsResult, CodeDiagnosticsService, CodeValidationInput, CodeValidationResult, CodeValidationRuntime, CodeValidationServiceDefinition, CodeValidationServiceFacade, DevelopmentProvider, DevelopmentRequest, DevelopmentResult, DevelopmentRuntime, DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, DevelopmentTask, GitHubActionsClient, GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, TYPESCRIPT_LANGUAGE_SERVER_PACKAGE, TYPESCRIPT_LANGUAGE_SERVER_VERSION, TypeScriptLanguageServerNotificationInput, TypeScriptLanguageServerRequestInput, TypeScriptLanguageServerResponse, TypeScriptLanguageServerServiceDefinition, TypeScriptLanguageServerServiceFacade, TypeScriptLanguageServerStartInput, TypeScriptLanguageServerStatus, ValidationDiagnostic, ValidationLayer, WebContainerCommand, WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, WorkflowRun, codeDiagnosticsService, resolveDevelopmentCommand } from './development/index.js';
+export { AgentHarnessProvider, AgentHarnessProviderInfo, AgentHarnessResult, AgentHarnessRunInput, AgentHarnessRuntime, AgentHarnessServiceContract, AgentHarnessServiceDefinition, AgentHarnessServiceFacade, CodeDiagnosticsInput, CodeDiagnosticsResult, CodeDiagnosticsService, CodeValidationInput, CodeValidationResult, CodeValidationRuntime, CodeValidationServiceDefinition, CodeValidationServiceFacade, DevelopmentProvider, DevelopmentRequest, DevelopmentResult, DevelopmentRuntime, DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, DevelopmentTask, GitHubActionsClient, GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, TYPESCRIPT_LANGUAGE_SERVER_PACKAGE, TYPESCRIPT_LANGUAGE_SERVER_VERSION, TypeScriptLanguageServerNotificationInput, TypeScriptLanguageServerRequestInput, TypeScriptLanguageServerResponse, TypeScriptLanguageServerServiceDefinition, TypeScriptLanguageServerServiceFacade, TypeScriptLanguageServerStartInput, TypeScriptLanguageServerStatus, ValidationDiagnostic, ValidationLayer, WebContainerCommand, WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, WorkflowRun, codeDiagnosticsService, resolveDevelopmentCommand } from './development/index.js';
 export { EndpointDescriptor, IService, ProtocolAdapter, ServiceDefinition } from '@ultrst-armada/krnl';
 import 'react';
 
@@ -291,7 +291,7 @@ declare function listBackblazeBuckets(payload: any, rawUserId?: string, env?: Re
     buckets?: any[];
     error?: string;
 }>;
-declare const srklListBackblazeBuckets: (keyId?: string, applicationKey?: string, bucketId?: string, bucketName?: string, userId?: string) => Promise<{
+declare const srklListBackblazeBuckets: (keyId?: string, applicationKey?: string, bucketId?: string, bucketName?: string, userId?: string, accountId?: string) => Promise<{
     success: boolean;
     buckets?: any[];
     error?: string;