@prismer/sdk 1.9.22 → 2.0.0

package/dist/index.mjs

@@ -1498,6 +1498,106 @@ var ENVIRONMENTS = {
   production: "https://prismer.cloud"
 };
 
+// src/im/workspace/tasks.ts
+var CARD_KANBAN_STATUSES = /* @__PURE__ */ new Set([
+  "backlog",
+  "todo",
+  "in_progress",
+  "review",
+  "completed",
+  "failed",
+  "cancelled",
+  "pending",
+  "assigned",
+  "running",
+  "done"
+]);
+var CARD_PRIORITIES = /* @__PURE__ */ new Set([
+  "low",
+  "medium",
+  "high",
+  "urgent"
+]);
+function readCardKanbanMetadata(source) {
+  const metadata = readSourceMetadata(source);
+  const nestedKanban = readRecord(metadata.kanban);
+  const fields = nestedKanban ? { ...metadata, ...nestedKanban } : metadata;
+  return toCanonicalCardKanbanMetadata(fields);
+}
+function writeCardKanbanMetadata(metadata, kanban) {
+  const previous = readRecord(metadata) ?? {};
+  const previousKanban = readRecord(previous.kanban);
+  const currentView = toWritableCardKanbanMetadata(readCardKanbanMetadata(previous));
+  const nextView = toWritableCardKanbanMetadata(toCanonicalCardKanbanMetadata(kanban));
+  const nextKanban = toWritableCardKanbanMetadata({
+    ...previousKanban ? omitLegacyOrder(previousKanban) : {},
+    ...currentView,
+    ...nextView
+  });
+  return {
+    ...omitLegacyOrder(previous),
+    ...nextKanban,
+    kanban: nextKanban
+  };
+}
+function readSourceMetadata(source) {
+  const record = readRecord(source);
+  if (!record) return {};
+  return readRecord(record.metadata) ?? record;
+}
+function toCanonicalCardKanbanMetadata(source) {
+  const record = readRecord(source) ?? {};
+  const metadata = {};
+  const columnId = readString(record.columnId);
+  const cardOrder = readFiniteNumber(record.cardOrder) ?? readFiniteNumber(record.order);
+  const cardStatus = readCardKanbanStatus(record.cardStatus);
+  const cardPriority = readCardPriority(record.cardPriority);
+  const cardLabels = readCardLabels(record.cardLabels);
+  if (columnId) metadata.columnId = columnId;
+  if (cardOrder !== void 0) metadata.cardOrder = cardOrder;
+  if (cardStatus) metadata.cardStatus = cardStatus;
+  if (cardPriority) metadata.cardPriority = cardPriority;
+  if (cardLabels) metadata.cardLabels = cardLabels;
+  return metadata;
+}
+function toWritableCardKanbanMetadata(view) {
+  return view.cardStatus === "done" ? { ...view, cardStatus: "completed" } : view;
+}
+function omitLegacyOrder(record) {
+  const { order: _legacyOrder, ...rest } = record;
+  return rest;
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function readString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function readFiniteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readCardKanbanStatus(value) {
+  return typeof value === "string" && CARD_KANBAN_STATUSES.has(value) ? value : void 0;
+}
+function readCardPriority(value) {
+  return typeof value === "string" && CARD_PRIORITIES.has(value) ? value : void 0;
+}
+function readCardLabels(value) {
+  const record = readRecord(value);
+  if (!record) return void 0;
+  const labels = {};
+  const color = readString(record.color);
+  const emoji = readString(record.emoji);
+  const tagIds = Array.isArray(record.tagIds) && record.tagIds.every((tagId) => typeof tagId === "string") ? [...record.tagIds] : void 0;
+  if (color) labels.color = color;
+  if (emoji) labels.emoji = emoji;
+  if (tagIds) labels.tagIds = tagIds;
+  return Object.keys(labels).length > 0 ? labels : void 0;
+}
+
+// src/im/workspace/assets.ts
+var WORKSPACE_ASSETS_ROUTE = "/api/im/assets";
+
 // src/storage.ts
 var MemoryStorage = class {
   constructor() {
@@ -2949,10 +3049,13 @@ function createEnrichedExtractor(config) {
 }
 
 // src/evolution-runtime.ts
+var DEFAULT_OUTBOX_MAX_ATTEMPTS = 5;
 var EvolutionRuntime = class {
   constructor(client, config) {
     this.client = client;
     this.outbox = [];
+    /** Entries that exceeded `outboxMaxAttempts`. Public-readable for tests/ops. */
+    this.deadLetter = [];
     this.started = false;
     // Session tracking
     this._sessions = [];
@@ -2962,7 +3065,8 @@ var EvolutionRuntime = class {
       enrichment: config?.enrichment ?? { mode: "rules" },
       scope: config?.scope ?? "global",
       outboxMaxSize: config?.outboxMaxSize ?? 50,
-      outboxFlushMs: config?.outboxFlushMs ?? 5e3
+      outboxFlushMs: config?.outboxFlushMs ?? 5e3,
+      outboxMaxAttempts: config?.outboxMaxAttempts ?? DEFAULT_OUTBOX_MAX_ATTEMPTS
     };
     this.scope = this.config.scope;
     this.cache = new EvolutionCache();
@@ -3028,8 +3132,9 @@ var EvolutionRuntime = class {
         confidence,
         fromCache
       };
+      const narrowed = action === "apply_gene" || action === "create_suggested" || action === "none" ? action : "none";
       return {
-        action,
+        action: narrowed,
         geneId,
         gene,
         strategy,
@@ -3180,25 +3285,53 @@ var EvolutionRuntime = class {
     } catch {
     }
   }
-  /** Flush outbox to server */
+  /**
+   * Flush outbox to server. Fire-and-forget contract: never blocks the caller's
+   * critical path and never throws. Failed entries are retried until they hit
+   * `outboxMaxAttempts`, then moved to `deadLetter` and reported via
+   * `console.warn` so ops can detect a persistent failure.
+   */
   async flush() {
     if (this.outbox.length === 0) return;
     const batch = this.outbox.splice(0, this.config.outboxMaxSize);
-    const promises = batch.map(
-      (entry) => this.client.record({
-        gene_id: entry.geneId,
-        signals: entry.signals.map((s) => s.type),
-        outcome: entry.outcome,
-        summary: entry.summary,
-        score: entry.score,
-        metadata: entry.metadata,
-        scope: this.scope
-      }).catch(() => {
-        this.outbox.push(entry);
-      })
-    );
+    const promises = batch.map(async (entry) => {
+      try {
+        const res = await this.client.record({
+          gene_id: entry.geneId,
+          signals: entry.signals.map((s) => s.type),
+          outcome: entry.outcome,
+          summary: entry.summary,
+          score: entry.score,
+          metadata: entry.metadata,
+          scope: this.scope
+        });
+        if (!res.ok) {
+          this._handleOutboxFailure(entry, res.error?.message ?? "record returned ok=false");
+        }
+      } catch (err) {
+        this._handleOutboxFailure(entry, err instanceof Error ? err.message : String(err));
+      }
+    });
     await Promise.allSettled(promises);
   }
+  /**
+   * Bump the attempt counter and either re-queue (under ceiling) or move to
+   * dead-letter. Always synchronous — caller's `flush()` already wraps in a
+   * promise.allSettled.
+   */
+  _handleOutboxFailure(entry, lastError) {
+    const attempts = (entry.attempts ?? 0) + 1;
+    const ceiling = this.config.outboxMaxAttempts;
+    if (attempts >= ceiling) {
+      const dropped = { ...entry, attempts, lastError, droppedAt: Date.now() };
+      this.deadLetter.push(dropped);
+      console.warn(
+        `[EvolutionRuntime] outbox entry dropped after ${attempts} attempts: gene=${entry.geneId} outcome=${entry.outcome} error=${lastError}`
+      );
+      return;
+    }
+    this.outbox.push({ ...entry, attempts });
+  }
 };
 
 // src/index.ts
@@ -3297,6 +3430,7 @@ var DirectClient = class {
       content,
       type: options?.type ?? "text",
       metadata: options?.metadata,
+      attachments: options?.attachments,
       parentId: options?.parentId,
       quotedMessageId: options?.quotedMessageId
     });
@@ -3331,6 +3465,7 @@ var GroupsClient = class {
       content,
       type: options?.type ?? "text",
       metadata: options?.metadata,
+      attachments: options?.attachments,
       parentId: options?.parentId,
       quotedMessageId: options?.quotedMessageId
     });
@@ -3409,6 +3544,7 @@ var MessagesClient = class {
       content,
       type: options?.type ?? "text",
       metadata: options?.metadata,
+      attachments: options?.attachments,
       parentId: options?.parentId,
       quotedMessageId: options?.quotedMessageId
     });
@@ -3469,6 +3605,11 @@ var ContactsClient = class {
     const query = {};
     if (options?.type) query.type = options.type;
     if (options?.capability) query.capability = options.capability;
+    if (options?.status) query.status = options.status;
+    if (options?.onlineOnly) query.onlineOnly = options.onlineOnly;
+    if (options?.q) query.q = options.q;
+    if (options?.limit) query.limit = options.limit;
+    if (options?.offset) query.offset = options.offset;
     return this._r("GET", "/api/im/discover", void 0, query);
   }
   // ─── Friend System (v1.8.0 P9) ─────────────────────────
@@ -3682,6 +3823,32 @@ var TasksClient = class {
   async cancel(taskId) {
     return this._r("DELETE", `/api/im/tasks/${taskId}`);
   }
+  /**
+   * v2.0 release 200 §6.1 — unified state-machine transition.
+   *
+   * Drives every kanban / approve / reject / cancel / blocked / retry /
+   * restore action through one endpoint. The 5 legacy endpoints
+   * (start/complete/approve/reject/cancel) remain for backward
+   * compatibility but new integrations should prefer this entrypoint.
+   *
+   * Server responds 409 (`code: 'invalid-transition'`) if the requested
+   * `to` is not in the TRANSITIONS matrix from the current status, or
+   * 403 (`code: 'forbidden'`) if the actor's tier is not in the rule's
+   * `allowedActors`.
+   */
+  async transition(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/transition`, options);
+  }
+  /**
+   * v2.0 release 200 §5.3 — admin escape-hatch.
+   *
+   * Bypasses the TRANSITIONS matrix. Restricted to workspace owner /
+   * admin / trustTier>=4. Reason is required; the call is audit-logged
+   * with `force_transition: true`. UI does NOT expose this — ops only.
+   */
+  async forceTransition(taskId, options) {
+    return this._r("POST", `/api/im/tasks/${taskId}/force-transition`, options);
+  }
 };
 var MemoryClient = class {
   constructor(_r) {
@@ -3810,9 +3977,118 @@ var SecurityClient = class {
     return this._r("DELETE", `/api/im/conversations/${conversationId}/keys/${keyUserId}`);
   }
 };
+var EvolutionSkillsClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /** List the skill catalog. Alias of search() for the v2.0 public surface. */
+  async list(options) {
+    return this.search(options);
+  }
+  /** Browse and search the skill catalog. */
+  async search(options) {
+    const query = {};
+    if (options?.query) query.query = options.query;
+    if (options?.category) query.category = options.category;
+    if (options?.source) query.source = options.source;
+    if (options?.compatibility) query.compatibility = options.compatibility;
+    if (options?.sort) query.sort = options.sort;
+    if (options?.page != null) query.page = String(options.page);
+    if (options?.limit != null) query.limit = String(options.limit);
+    return this._r("GET", "/api/im/skills/search", void 0, query);
+  }
+  /** Get skill catalog stats. */
+  async stats() {
+    return this._r("GET", "/api/im/skills/stats");
+  }
+  /** List available skill categories. */
+  async categories() {
+    return this._r("GET", "/api/im/skills/categories");
+  }
+  /** List trending skills. */
+  async trending(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/skills/trending", void 0, query);
+  }
+  /** List skills created by the authenticated agent. */
+  async created() {
+    return this._r("GET", "/api/im/skills/created");
+  }
+  /** Get skill detail by slug or ID. */
+  async get(slugOrId) {
+    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}`);
+  }
+  /** Get full SKILL.md content and package metadata. */
+  async content(slugOrId) {
+    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}/content`);
+  }
+  /** Create/submit a workspace or community skill. */
+  async create(input) {
+    return this._r("POST", "/api/im/skills", input);
+  }
+  /** Update a skill. */
+  async update(skillId, input) {
+    return this._r("PATCH", `/api/im/skills/${encodeURIComponent(skillId)}`, input);
+  }
+  /** Soft-delete/deprecate a skill. */
+  async delete(skillId) {
+    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(skillId)}`);
+  }
+  /** Install a skill for the authenticated agent. */
+  async install(slugOrId, scope) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, scope ? { scope } : void 0);
+  }
+  /** Uninstall a skill for the authenticated agent. */
+  async uninstall(slugOrId, scope) {
+    const query = scope ? { scope } : void 0;
+    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, void 0, query);
+  }
+  /**
+   * List installed skills. When agentId is supplied, this uses the v2.0 Layer 5
+   * route and includes daemon sync state; otherwise it keeps the legacy current-agent route.
+   */
+  async installed(options) {
+    const query = {};
+    if (options?.workspaceId) query.workspaceId = options.workspaceId;
+    if (options?.includeInactive) query.includeInactive = "true";
+    if (options?.agentId) {
+      return this._r("GET", `/api/im/agents/${encodeURIComponent(options.agentId)}/skills`, void 0, query);
+    }
+    return this._r("GET", "/api/im/skills/installed", void 0, query);
+  }
+  /** Install a skill to a specific agent. */
+  async installForAgent(agentId, skillIdOrSlug, options) {
+    return this._r("POST", `/api/im/agents/${encodeURIComponent(agentId)}/skills`, {
+      skillId: skillIdOrSlug,
+      ...options
+    });
+  }
+  /** Disable/uninstall a skill from a specific agent. Built-ins are disabled cloud-side. */
+  async uninstallFromAgent(agentId, skillIdOrSlug, options) {
+    return this._r("DELETE", `/api/im/agents/${encodeURIComponent(agentId)}/skills`, {
+      skillId: skillIdOrSlug,
+      workspaceId: options?.workspaceId
+    });
+  }
+  /** List skills whose daemon sync state is not current. */
+  async pending(agentId, workspaceId) {
+    const query = workspaceId ? { workspaceId } : void 0;
+    return this._r("GET", `/api/im/agents/${encodeURIComponent(agentId)}/skills/pending`, void 0, query);
+  }
+  /** Acknowledge daemon sync for an installed skill. */
+  async ack(agentId, input) {
+    return this._r("POST", `/api/im/agents/${encodeURIComponent(agentId)}/skills/ack`, input);
+  }
+  /** Star a skill. */
+  async star(skillId) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(skillId)}/star`);
+  }
+};
 var EvolutionClient = class {
   constructor(_r) {
     this._r = _r;
+    this.skills = new EvolutionSkillsClient(_r);
   }
   // ── Public endpoints (no auth required) ──
   /** Get evolution stats */
@@ -3942,7 +4218,7 @@ var EvolutionClient = class {
     const { outcome, score, summary, strategy_used, scope, ...analyzeOpts } = options;
     const analysis = await this.analyze({ ...analyzeOpts, ...scope ? { scope } : {} });
     if (!analysis.ok || !analysis.data) {
-      return { ok: false, error: analysis.error };
+      return { ok: false, ...analysis.error ? { error: analysis.error } : {} };
     }
     const data = analysis.data;
     const geneId = data.gene_id;
@@ -4056,39 +4332,35 @@ var EvolutionClient = class {
   }
   /** Search skills catalog */
   async searchSkills(options) {
-    const q = {};
-    if (options?.query) q.query = options.query;
-    if (options?.category) q.category = options.category;
-    if (options?.limit != null) q.limit = String(options.limit);
-    return this._r("GET", "/api/im/skills/search", void 0, q);
+    return this.skills.search(options);
   }
   /** Get skill catalog stats */
   async getSkillStats() {
-    return this._r("GET", "/api/im/skills/stats");
+    return this.skills.stats();
   }
   /** Install a skill — creates Gene + returns content + install guide */
   async installSkill(slugOrId, scope) {
-    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, scope ? { scope } : void 0);
+    return this.skills.install(slugOrId, scope);
   }
   /** Uninstall a skill */
-  async uninstallSkill(slugOrId) {
-    return this._r("DELETE", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  async uninstallSkill(slugOrId, scope) {
+    return this.skills.uninstall(slugOrId, scope);
   }
   /** List installed skills for this agent */
-  async installedSkills() {
-    return this._r("GET", "/api/im/skills/installed");
+  async installedSkills(options) {
+    return this.skills.installed(options);
   }
   /** Get full skill content (SKILL.md + package info) */
   async getSkillContent(slugOrId) {
-    return this._r("GET", `/api/im/skills/${encodeURIComponent(slugOrId)}/content`);
+    return this.skills.content(slugOrId);
   }
   /** Create/submit a community skill */
   async createSkill(input) {
-    return this._r("POST", "/api/im/skills", input);
+    return this.skills.create(input);
   }
   /** Star a skill (increment community rating) */
   async starSkill(skillId) {
-    return this._r("POST", `/api/im/skills/${encodeURIComponent(skillId)}/star`);
+    return this.skills.star(skillId);
   }
   /**
    * Install a skill and write SKILL.md to local filesystem.
@@ -4098,19 +4370,26 @@ var EvolutionClient = class {
    */
   async installSkillLocal(slugOrId, options) {
     const result = await this.installSkill(slugOrId);
-    if (!result.ok || !result.data) return result;
-    let content = result.data.skill?.content || "";
+    if (!result.ok || !result.data) {
+      return result;
+    }
+    const installData = result.data;
+    const withLocalPaths = (localPaths2) => ({
+      ok: true,
+      data: { ...installData, localPaths: localPaths2 }
+    });
+    let content = installData.skill?.content || "";
     if (!content) {
       const contentResult = await this.getSkillContent(slugOrId);
       content = contentResult.data?.content || "";
     }
     if (!content) {
-      return { ...result, data: { ...result.data, localPaths: [] } };
+      return withLocalPaths([]);
     }
-    const rawSlug = result.data.skill?.slug || slugOrId;
+    const rawSlug = installData.skill?.slug || slugOrId;
     const slug = rawSlug.replace(/[\/\\]/g, "").replace(/\.\./g, "");
     if (!slug) {
-      return { ...result, data: { ...result.data, localPaths: [] } };
+      return withLocalPaths([]);
     }
     const localPaths = [];
     try {
@@ -4130,7 +4409,7 @@ var EvolutionClient = class {
         "opencode": path.join(home, ".config", "opencode", "skills", slug),
         "plugin": path.join(pluginBase, "skills", slug)
       };
-      const targets = options?.platforms || Object.keys(platformPaths);
+      const targets = options?.platforms ?? Object.keys(platformPaths);
       for (const platform of targets) {
         const dir = platformPaths[platform];
         if (!dir) continue;
@@ -4144,7 +4423,7 @@ var EvolutionClient = class {
       }
     } catch {
     }
-    return { ...result, data: { ...result.data, localPaths } };
+    return withLocalPaths(localPaths);
   }
   /**
    * Uninstall a skill and remove local SKILL.md files.
@@ -4152,8 +4431,13 @@ var EvolutionClient = class {
   async uninstallSkillLocal(slugOrId) {
     const result = await this.uninstallSkill(slugOrId);
     const removedPaths = [];
+    const withRemoved = (ok, paths) => ({
+      ok: result.ok,
+      ...result.error ? { error: result.error } : {},
+      data: { uninstalled: ok, removedPaths: paths }
+    });
     const slug = safeSlug(slugOrId);
-    if (!slug) return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    if (!slug) return withRemoved(result.data?.uninstalled ?? false, removedPaths);
     try {
       const fs = await import("fs");
       const path = await import("path");
@@ -4177,7 +4461,7 @@ var EvolutionClient = class {
       }
     } catch {
     }
-    return { ...result, data: { uninstalled: result.data?.uninstalled ?? false, removedPaths } };
+    return withRemoved(result.data?.uninstalled ?? false, removedPaths);
   }
   /**
    * Sync all installed skills to local filesystem.
@@ -4217,7 +4501,7 @@ var EvolutionClient = class {
           "opencode": path.join(home, ".config", "opencode", "skills", slug),
           "plugin": path.join(pluginBase, "skills", slug)
         };
-        const targets = options?.platforms || Object.keys(platformPaths);
+        const targets = options?.platforms ?? Object.keys(platformPaths);
         for (const platform of targets) {
           const dir = platformPaths[platform];
           if (!dir) continue;
@@ -4266,12 +4550,34 @@ var EvolutionClient = class {
     if (since != null) query.since = String(since);
     return this._r("GET", "/api/im/evolution/sync/snapshot", void 0, query);
   }
-  /** Bidirectional sync: push local outcomes and pull remote updates */
+  /**
+   * Bidirectional sync: push local outcomes and pull remote updates.
+   *
+   * Accepts either the flat shape (`pushOutcomes` / `pullSince`) used by older
+   * callers or the nested shape (`push` / `pull`) that mirrors the wire format
+   * expected by `POST /api/im/evolution/sync`. The nested shape is preferred for
+   * new code because it lets you pin a scope per-side.
+   */
   async sync(options) {
     const body = {};
-    if (options?.pushOutcomes) body.push = { outcomes: options.pushOutcomes };
-    if (options?.pullSince != null) body.pull = { since: options.pullSince };
-    return this._r("POST", "/api/im/evolution/sync", body);
+    const outcomes = options?.push?.outcomes ?? options?.pushOutcomes;
+    if (outcomes) {
+      body.push = {
+        outcomes,
+        ...options?.push?.scope ? { scope: options.push.scope } : {},
+        ...options?.push?.workspaceId ? { workspaceId: options.push.workspaceId } : {}
+      };
+    }
+    const since = options?.pull?.since ?? options?.pullSince;
+    if (since != null) {
+      body.pull = {
+        since,
+        ...options?.pull?.scope ? { scope: options.pull.scope } : {}
+      };
+    }
+    const query = {};
+    if (options?.scope) query.scope = options.scope;
+    return this._r("POST", "/api/im/evolution/sync", body, query);
   }
 };
 function safeSlug(input) {
@@ -4315,6 +4621,26 @@ var WorkspacesClient = class {
   async archive(workspaceId) {
     return this._r("DELETE", `/api/im/workspaces/${workspaceId}`);
   }
+  /**
+   * Get the workspace's orchestrator agent (Chief of Staff) — readable by any
+   * member. Returns `{ workspace, orchestrator: null }` when no active
+   * appointment exists. See release 200 §4.
+   */
+  async getOrchestrator(workspaceId) {
+    return this._r("GET", `/api/im/workspaces/${workspaceId}/orchestrator`);
+  }
+  /**
+   * Appoint an agent as the workspace's orchestrator. Owner-only. If an
+   * orchestrator is already active, this auto-revokes the previous one in the
+   * same UPDATE.
+   */
+  async appointOrchestrator(workspaceId, agentImUserId) {
+    return this._r("POST", `/api/im/workspaces/${workspaceId}/orchestrator`, { agentImUserId });
+  }
+  /** Revoke the workspace's current orchestrator. Owner-only. Idempotent. */
+  async revokeOrchestrator(workspaceId) {
+    return this._r("DELETE", `/api/im/workspaces/${workspaceId}/orchestrator`);
+  }
 };
 var WorkspaceFilesClient = class {
   constructor(_r) {
@@ -4348,6 +4674,83 @@ var WorkspaceFilesClient = class {
     return this._r("GET", `/api/im/workspaces/${workspaceId}/files/${fileId}/history`);
   }
 };
+var MAX_IM_ASSET_BYTES = 1024 * 1024 * 1024;
+var DIRECT_ASSET_UPLOAD_FALLBACK_STATUSES = /* @__PURE__ */ new Set([404, 501, 503]);
+function toHex(bytes) {
+  return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function sha256BytesHex(bytes) {
+  if (globalThis.crypto?.subtle) {
+    const ab = new ArrayBuffer(bytes.byteLength);
+    new Uint8Array(ab).set(bytes);
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", ab);
+    return toHex(new Uint8Array(digest));
+  }
+  const { createHash } = await import("crypto");
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function bytesToBlob(bytes, mimeType) {
+  const ab = new ArrayBuffer(bytes.byteLength);
+  new Uint8Array(ab).set(bytes);
+  return new Blob([ab], { type: mimeType });
+}
+function isNamedFile(input) {
+  return typeof File !== "undefined" && input instanceof File;
+}
+function normalizeStringHeaders(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const out = {};
+  for (const [key, raw] of Object.entries(value)) {
+    if (typeof raw === "string") out[key] = raw;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function isDirectAssetUploadPlan(value) {
+  if (!value || typeof value !== "object") return false;
+  const plan = value;
+  if (plan.mode === "single") {
+    return typeof plan.uploadUrl === "string" && typeof plan.bucket === "string" && typeof plan.key === "string";
+  }
+  if (plan.mode === "multipart") {
+    return typeof plan.bucket === "string" && typeof plan.key === "string" && typeof plan.uploadId === "string" && typeof plan.partSizeBytes === "number" && Array.isArray(plan.parts) && plan.parts.every((part) => {
+      const item = part;
+      return typeof item.url === "string" && Number.isInteger(item.partNumber);
+    });
+  }
+  return false;
+}
+function assetUploadError(code, message) {
+  return { ok: false, error: { code, message } };
+}
+async function normalizeAssetUploadInput(input, options) {
+  let bytes;
+  let fileName;
+  if (typeof input === "string") {
+    const fs = await import("fs");
+    const path = await import("path");
+    const buf = await fs.promises.readFile(input);
+    bytes = new Uint8Array(buf);
+    fileName = options.fileName || path.basename(input);
+  } else if (typeof Blob !== "undefined" && input instanceof Blob) {
+    const ab = await input.arrayBuffer();
+    bytes = new Uint8Array(ab);
+    fileName = options.fileName || (isNamedFile(input) ? input.name : "");
+    if (!fileName) throw new Error("fileName is required when uploading Blob without name");
+  } else if (input instanceof Uint8Array) {
+    bytes = input;
+    fileName = options.fileName || "";
+    if (!fileName) throw new Error("fileName is required when uploading Buffer or Uint8Array");
+  } else {
+    throw new Error("Unsupported input type");
+  }
+  const sizeBytes = bytes.byteLength;
+  if (sizeBytes > MAX_IM_ASSET_BYTES) {
+    throw new Error("Asset exceeds 1 GB cap");
+  }
+  const mimeType = options.mimeType || guessMimeType(fileName);
+  const contentHash = await sha256BytesHex(bytes);
+  return { bytes, fileName, mimeType, sizeBytes, contentHash };
+}
 var AssetsClient = class {
   constructor(_r, _baseUrl, _fetchFn, _getAuthHeaders) {
     this._r = _r;
@@ -4414,57 +4817,130 @@ var AssetsClient = class {
     };
   }
   /**
-   * Upload bytes as an asset (multipart). 100 MB hard cap; >50 MB returns
-   * 413 with `USE_PRESIGNED` — use S3 presign flow for those (not yet wrapped).
+   * Upload bytes as an asset. Uses direct-to-S3 upload when the server exposes
+   * `/assets/direct-upload/*`; falls back to legacy multipart POST for local
+   * filesystem mode and older deployments. The client always sends SHA-256 for
+   * server-side byte integrity checks. Hard cap: 1 GB.
    */
   async upload(input, options) {
-    let bytes;
-    let fileName;
-    if (typeof input === "string") {
-      const fs = await import("fs");
-      const path = await import("path");
-      const buf = await fs.promises.readFile(input);
-      bytes = new Uint8Array(buf);
-      fileName = options.fileName || path.basename(input);
-    } else if (typeof Blob !== "undefined" && input instanceof Blob) {
-      const ab2 = await input.arrayBuffer();
-      bytes = new Uint8Array(ab2);
-      fileName = options.fileName || (input instanceof File ? input.name : "");
-      if (!fileName) throw new Error("fileName is required when uploading Blob without name");
-    } else if (input instanceof Uint8Array) {
-      bytes = input;
-      fileName = options.fileName || "";
-      if (!fileName) throw new Error("fileName is required when uploading Buffer or Uint8Array");
-    } else {
-      throw new Error("Unsupported input type");
+    const normalized = await normalizeAssetUploadInput(input, options);
+    const direct = await this._tryDirectUpload(normalized, options);
+    if (direct) return direct;
+    return this._uploadMultipart(normalized, options);
+  }
+  async _tryDirectUpload(file, options) {
+    const init = await this._postAssetJson("/direct-upload/init", {
+      workspaceId: options.workspaceId,
+      filename: file.fileName,
+      mime: file.mimeType,
+      sizeBytes: file.sizeBytes,
+      contentHash: file.contentHash
+    });
+    if (!init.response.ok) {
+      if (DIRECT_ASSET_UPLOAD_FALLBACK_STATUSES.has(init.response.status)) return null;
+      return init.data && init.data.ok === false ? {
+        ok: false,
+        error: init.data.error ?? {
+          code: "http_error",
+          message: `Direct upload init failed (${init.response.status})`
+        }
+      } : assetUploadError("http_error", `Direct upload init failed (${init.response.status})`);
     }
-    const mimeType = options.mimeType || guessMimeType(fileName);
-    const sizeBytes = bytes.byteLength;
-    if (sizeBytes > 100 * 1024 * 1024) {
-      throw new Error("Asset exceeds 100 MB cap");
+    if (!isDirectAssetUploadPlan(init.data?.data)) return null;
+    const plan = init.data.data;
+    try {
+      const parts = await this._putDirectUploadBytes(plan, file, options.onProgress);
+      const complete = await this._postAssetJson("/direct-upload/complete", {
+        workspaceId: options.workspaceId,
+        filename: file.fileName,
+        mime: file.mimeType,
+        sizeBytes: file.sizeBytes,
+        contentHash: file.contentHash,
+        kind: options.kind,
+        metadata: options.metadata,
+        sourceTaskId: options.sourceTaskId,
+        sourceAgentImUserId: options.sourceAgentImUserId,
+        bucket: plan.bucket,
+        key: plan.key,
+        ...plan.mode === "multipart" ? { uploadId: plan.uploadId, parts: parts ?? [] } : {}
+      });
+      if (!complete.response.ok) {
+        return complete.data && complete.data.ok === false ? complete.data : assetUploadError("http_error", `Direct upload complete failed (${complete.response.status})`);
+      }
+      if (!complete.data) {
+        return assetUploadError("invalid_response", "Direct upload complete returned an empty response");
+      }
+      return complete.data;
+    } catch {
+      return null;
+    }
+  }
+  async _postAssetJson(path, body) {
+    const response = await this._fetchFn(`${this._baseUrl}/api/im/assets${path}`, {
+      method: "POST",
+      headers: {
+        ...this._getAuthHeaders(),
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      body: JSON.stringify(body)
+    });
+    const data = await response.json().catch(() => null);
+    return { response, data };
+  }
+  async _putDirectUploadBytes(plan, file, onProgress) {
+    if (plan.mode === "single") {
+      const response = await this._fetchFn(plan.uploadUrl, {
+        method: plan.method ?? "PUT",
+        headers: normalizeStringHeaders(plan.headers),
+        body: bytesToBlob(file.bytes, file.mimeType)
+      });
+      if (!response.ok) throw new Error(`signed PUT failed (${response.status})`);
+      onProgress?.(file.sizeBytes, file.sizeBytes);
+      return null;
+    }
+    const completedParts = [];
+    let uploaded = 0;
+    for (const part of plan.parts) {
+      const start = (part.partNumber - 1) * plan.partSizeBytes;
+      const end = Math.min(start + plan.partSizeBytes, file.sizeBytes);
+      const chunk = file.bytes.slice(start, end);
+      const response = await this._fetchFn(part.url, { method: "PUT", body: bytesToBlob(chunk, file.mimeType) });
+      if (!response.ok) throw new Error(`signed multipart PUT failed for part ${part.partNumber} (${response.status})`);
+      const etag = response.headers.get("etag")?.replace(/^"|"$/g, "");
+      if (!etag) throw new Error(`signed multipart PUT missing ETag for part ${part.partNumber}`);
+      completedParts.push({ partNumber: part.partNumber, etag });
+      uploaded += chunk.byteLength;
+      onProgress?.(uploaded, file.sizeBytes);
     }
+    return completedParts;
+  }
+  async _uploadMultipart(file, options) {
+    const { bytes, fileName, mimeType, sizeBytes, contentHash } = file;
     const formData = new FormData();
-    const ab = new ArrayBuffer(bytes.byteLength);
-    new Uint8Array(ab).set(bytes);
-    formData.append("file", new Blob([ab], { type: mimeType }), fileName);
+    formData.append("file", bytesToBlob(bytes, mimeType), fileName);
     formData.append("workspaceId", options.workspaceId);
     if (options.kind) formData.append("kind", options.kind);
     if (options.sourceAgentImUserId) formData.append("sourceAgentImUserId", options.sourceAgentImUserId);
     if (options.sourceTaskId) formData.append("sourceTaskId", options.sourceTaskId);
     if (options.metadata) formData.append("metadata", JSON.stringify(options.metadata));
+    formData.append("contentSha256", contentHash);
     const resp = await this._fetchFn(`${this._baseUrl}/api/im/assets`, {
       method: "POST",
       body: formData,
-      headers: this._getAuthHeaders()
+      headers: {
+        ...this._getAuthHeaders(),
+        "X-Content-Sha256": contentHash
+      }
     });
-    options.onProgress?.(sizeBytes, sizeBytes);
     const data = await resp.json().catch(() => ({}));
     if (!resp.ok) {
       return {
         ok: false,
-        error: data?.error || { code: "HTTP_ERROR", message: `Upload failed (${resp.status})` }
+        error: data?.error || { code: "http_error", message: `Upload failed (${resp.status})` }
       };
     }
+    options.onProgress?.(sizeBytes, sizeBytes);
     return data;
   }
 };
@@ -4830,6 +5306,7 @@ var IMRealtimeClient = class {
 };
 var IMClient = class {
   constructor(request, wsBase, fetchFn, getAuthHeaders, offlineManager, communityHubConfig) {
+    this._request = request;
     this.account = new AccountClient(request);
     this.direct = new DirectClient(request);
     this.groups = new GroupsClient(request);
@@ -4856,7 +5333,7 @@ var IMClient = class {
   }
   /** IM health check */
   async health() {
-    return this.account["_r"]("GET", "/api/im/health");
+    return this._request("GET", "/api/im/health");
   }
   /** Get workspace superset view with slot filtering */
   async getWorkspace(scope, slots, includeContent) {
@@ -4864,7 +5341,22 @@ var IMClient = class {
     if (scope) params.set("scope", scope);
     if (slots?.length) params.set("slots", slots.join(","));
     if (includeContent) params.set("includeContent", "true");
-    return this.workspace["_r"]("GET", `/api/im/workspace/view?${params}`);
+    return this._request("GET", `/api/im/workspace/view?${params}`);
+  }
+  /**
+   * Issue a typed IM API request via the shared `RequestFn` pipeline.
+   *
+   * Use this when you need to hit an IM endpoint that isn't (yet) exposed by a
+   * sub-client (e.g. `/api/im/approvals`). Same auth + offline routing + retry
+   * behaviour as the typed sub-clients.
+   *
+   * @example
+   *   const res = await client.im.request<ApprovalCreateResponse>(
+   *     'POST', '/api/im/approvals', { category, title, context, options },
+   *   );
+   */
+  async request(method, path, body, query) {
+    return this._request(method, path, body, query);
   }
 };
 var PrismerClient = class {
@@ -4932,6 +5424,10 @@ var PrismerClient = class {
       this._offlineManager,
       config.community ?? null
     );
+    this.workspaces = this.im.workspaces;
+    this.workspaceFiles = this.im.workspaceFiles;
+    this.assets = this.im.assets;
+    this.evolution = this.im.evolution;
   }
   /** Wait for identity to be ready (useful for tests or explicit await) */
   async ensureIdentity() {
@@ -4980,6 +5476,39 @@ var PrismerClient = class {
       await this._offlineManager.destroy();
     }
   }
+  /**
+   * Issue an authenticated raw HTTP request against the configured base URL,
+   * returning the underlying `Response` so callers can inspect headers
+   * (`Content-Range`, `Content-Length`, etc.) and stream the body.
+   *
+   * The path may be absolute (`/api/...`) or a full URL — full URLs are used
+   * verbatim (useful for following 302 redirects), otherwise the path is
+   * appended to the client's configured `baseUrl`. Authorization + `X-IM-Agent`
+   * headers are added automatically; caller-supplied headers in `init.headers`
+   * override them on collision.
+   *
+   * Use this for binary downloads / partial fetches; for normal JSON-envelope
+   * IM requests use `client.im.request()` (typed) or the typed sub-clients.
+   */
+  async fetchAuthed(url, init) {
+    const fullUrl = /^https?:\/\//i.test(url) ? url : `${this.baseUrl}${url}`;
+    const authHeaders = this._getAuthHeaders();
+    const callerHeaders = {};
+    if (init?.headers) {
+      const h = init.headers;
+      if (h instanceof Headers) {
+        h.forEach((v, k) => {
+          callerHeaders[k] = v;
+        });
+      } else if (Array.isArray(h)) {
+        for (const [k, v] of h) callerHeaders[k] = v;
+      } else {
+        Object.assign(callerHeaders, h);
+      }
+    }
+    const headers = { ...authHeaders, ...callerHeaders };
+    return this.fetchFn(fullUrl, { ...init ?? {}, headers });
+  }
   // --------------------------------------------------------------------------
   // Internal request helper
   // --------------------------------------------------------------------------
@@ -5016,18 +5545,18 @@ var PrismerClient = class {
         }
       }
       if (!response.ok) {
-        const err = data.error || { code: "HTTP_ERROR", message: `Request failed with status ${response.status}` };
+        const err = data.error || { code: "http_error", message: `Request failed with status ${response.status}` };
         return { ...data, success: false, ok: false, error: err };
       }
       return data;
     } catch (error) {
       if (error instanceof Error && error.name === "AbortError") {
-        return { success: false, ok: false, error: { code: "TIMEOUT", message: "Request timed out" } };
+        return { success: false, ok: false, error: { code: "timeout", message: "Request timed out" } };
       }
       return {
         success: false,
         ok: false,
-        error: { code: "NETWORK_ERROR", message: error instanceof Error ? error.message : "Unknown error" }
+        error: { code: "cloud_unreachable", message: error instanceof Error ? error.message : "Unknown error" }
       };
     } finally {
       clearTimeout(timeoutId);
@@ -5116,6 +5645,7 @@ export {
   EvolutionCache,
   EvolutionClient,
   EvolutionRuntime,
+  EvolutionSkillsClient,
   FilesClient,
   GroupsClient,
   IMClient,
@@ -5135,6 +5665,7 @@ export {
   SecurityClient,
   TabCoordinator,
   TasksClient,
+  WORKSPACE_ASSETS_ROUTE,
   WorkspaceClient,
   WorkspaceFilesClient,
   WorkspacesClient,
@@ -5150,5 +5681,7 @@ export {
   encryptForSend,
   extractSignals,
   guessMimeType,
-  safeSlug
+  readCardKanbanMetadata,
+  safeSlug,
+  writeCardKanbanMetadata
 };