@jami-studio/orchestra 0.1.0

package/LICENSE

@@ -0,0 +1,159 @@
+Apache License
+Version 2.0, January 2004
+https://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the
+copyright owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other
+entities that control, are controlled by, or are under common control with
+that entity. For the purposes of this definition, "control" means (i) the
+power, direct or indirect, to cause the direction or management of such
+entity, whether by contract or otherwise, or (ii) ownership of fifty percent
+or more of the outstanding shares, or (iii) beneficial ownership of such
+entity.
+
+"You" or "Your" shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications,
+including but not limited to software source code, documentation source, and
+configuration files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object
+code, generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form,
+made available under the License, as indicated by a copyright notice that is
+included in or attached to the work.
+
+"Derivative Works" shall mean any work, whether in Source or Object form,
+that is based on or derived from the Work and for which the editorial
+revisions, annotations, elaborations, or other modifications represent, as a
+whole, an original work of authorship. For the purposes of this License,
+Derivative Works shall not include works that remain separable from, or
+merely link or bind by name to the interfaces of, the Work and Derivative
+Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original
+version of the Work and any modifications or additions to that Work or
+Derivative Works thereof, that is intentionally submitted to Licensor for
+inclusion in the Work by the copyright owner or by an individual or Legal
+Entity authorized to submit on behalf of the copyright owner. For the purposes
+of this definition, "submitted" means any form of electronic, verbal, or
+written communication sent to the Licensor or its representatives, including
+but not limited to communication on electronic mailing lists, source code
+control systems, and issue tracking systems that are managed by, or on behalf
+of, the Licensor for the purpose of discussing and improving the Work, but
+excluding communication that is conspicuously marked or otherwise designated
+in writing by the copyright owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on
+behalf of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable copyright license to
+reproduce, prepare Derivative Works of, publicly display, publicly perform,
+sublicense, and distribute the Work and such Derivative Works in Source or
+Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of this
+License, each Contributor hereby grants to You a perpetual, worldwide,
+non-exclusive, no-charge, royalty-free, irrevocable patent license to make,
+have made, use, offer to sell, sell, import, and otherwise transfer the Work,
+where such license applies only to those patent claims licensable by such
+Contributor that are necessarily infringed by their Contribution alone or by
+combination of their Contribution with the Work to which such Contribution was
+submitted. If You institute patent litigation against any entity alleging that
+the Work or a Contribution incorporated within the Work constitutes direct or
+contributory patent infringement, then any patent licenses granted to You
+under this License for that Work shall terminate as of the date such
+litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the Work or
+Derivative Works thereof in any medium, with or without modifications, and in
+Source or Object form, provided that You meet the following conditions:
+
+(a) You must give any other recipients of the Work or Derivative Works a copy
+of this License; and
+
+(b) You must cause any modified files to carry prominent notices stating that
+You changed the files; and
+
+(c) You must retain, in the Source form of any Derivative Works that You
+distribute, all copyright, patent, trademark, and attribution notices from the
+Source form of the Work, excluding those notices that do not pertain to any
+part of the Derivative Works; and
+
+(d) If the Work includes a "NOTICE" text file as part of its distribution, then
+any Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of
+the following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents
+of the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a
+whole, provided Your use, reproduction, and distribution of the Work otherwise
+complies with the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise, any
+Contribution intentionally submitted for inclusion in the Work by You to the
+Licensor shall be under the terms and conditions of this License, without any
+additional terms or conditions. Notwithstanding the above, nothing herein shall
+supersede or modify the terms of any separate license agreement you may have
+executed with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade names,
+trademarks, service marks, or product names of the Licensor, except as
+required for reasonable and customary use in describing the origin of the Work
+and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
+writing, Licensor provides the Work on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied, including, without
+limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT,
+MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely
+responsible for determining the appropriateness of using or redistributing the
+Work and assume any risks associated with Your exercise of permissions under
+this License.
+
+8. Limitation of Liability. In no event and under no legal theory, whether in
+tort, contract, or otherwise, unless required by applicable law or agreed to in
+writing, shall any Contributor be liable to You for damages, including any
+direct, indirect, special, incidental, or consequential damages of any
+character arising as a result of this License or out of the use or inability
+to use the Work, including but not limited to damages for loss of goodwill,
+work stoppage, computer failure or malfunction, or any and all other
+commercial damages or losses, even if such Contributor has been advised of the
+possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing the Work or
+Derivative Works thereof, You may choose to offer, and charge a fee for,
+acceptance of support, warranty, indemnity, or other liability obligations
+and/or rights consistent with this License. However, in accepting such
+obligations, You may act only on Your own behalf and on Your sole
+responsibility, not on behalf of any other Contributor, and only if You agree
+to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS

package/README.md

@@ -0,0 +1,21 @@
+# @jami-studio/orchestra
+
+`@jami-studio/orchestra` is the Jami Studio orchestration control-plane package. It owns the durable dispatch state that sits above harness runs without moving model runtime, tool execution, memory, artifacts, or UI rendering out of their existing packages.
+
+## Current package surface
+
+- A 13-table Drizzle schema exported for Postgres and libSQL.
+- In-memory control-plane implementation for directory records, agents, dreams, tasks, runs, run events, tool calls, artifacts, grants, approvals, sealed secrets, key versions, and audit logs.
+- Sealed-at-rest vault envelopes using AES-256-GCM, explicit key-version records, and a rotation path that reseals existing secret envelopes.
+- Migration fixture descriptors for the initial vault schema and key rotation.
+- Source attribution for BuilderIO `@agent-native/dispatch@0.11.5`.
+
+## Source attribution
+
+The package records official npm metadata for BuilderIO `@agent-native/dispatch@0.11.5` in `DISPATCH_SOURCE_ATTRIBUTION`: MIT license, upstream repository, package version, and tarball URL verified on 2026-06-22. The implementation does not vendor upstream source files; dispatch concepts are reimplemented behind Jami-owned schema, approvals, grants, vault, and audit contracts.
+
+## Verification
+
+```powershell
+pnpm -C orchestra test
+```

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@jami-studio/orchestra",
+  "version": "0.1.0",
+  "description": "Jami Studio orchestration control-plane schema, sealed vault, approvals, grants, audit, dreams, and dispatch state.",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/studio-jami/jami-harness.git",
+    "directory": "orchestra"
+  },
+  "type": "module",
+  "exports": {
+    ".": "./src/index.mjs",
+    "./drizzle": "./src/drizzle.mjs"
+  },
+  "dependencies": {
+    "drizzle-orm": "^0.45.2",
+    "jose": "6.2.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "src/",
+    "README.md"
+  ],
+  "jamiRelease": {
+    "publishable": true
+  },
+  "scripts": {
+    "test": "node --test test/*.test.mjs"
+  }
+}

package/src/drizzle.mjs

@@ -0,0 +1,321 @@
+import { jsonb, integer, pgTable, text, timestamp } from "drizzle-orm/pg-core";
+import { integer as sqliteInteger, sqliteTable, text as sqliteText } from "drizzle-orm/sqlite-core";
+import { ORCHESTRA_SCHEMA_VERSION, ORCHESTRA_TABLES } from "./schema.mjs";
+
+const pgJson = (name) => jsonb(name).notNull();
+const pgCreated = (name) => timestamp(name, { withTimezone: true }).notNull();
+const pgOptionalTime = (name) => timestamp(name, { withTimezone: true });
+const sqliteJson = (name) => sqliteText(name, { mode: "json" }).notNull();
+const sqliteCreated = (name) => sqliteText(name).notNull();
+const sqliteOptionalTime = (name) => sqliteText(name);
+
+export const pgOrchestraOrgDirectory = pgTable("orchestra_org_directory", {
+  actorId: text("actor_id").primaryKey(),
+  actorType: text("actor_type").notNull(),
+  displayName: text("display_name").notNull(),
+  status: text("status").notNull(),
+  metadata: pgJson("metadata"),
+  createdAt: pgCreated("created_at"),
+  updatedAt: pgCreated("updated_at"),
+});
+
+export const pgOrchestraAgents = pgTable("orchestra_agents", {
+  agentId: text("agent_id").primaryKey(),
+  directoryActorId: text("directory_actor_id").notNull(),
+  modelFamily: text("model_family").notNull(),
+  capabilities: pgJson("capabilities"),
+  status: text("status").notNull(),
+  createdAt: pgCreated("created_at"),
+  updatedAt: pgCreated("updated_at"),
+});
+
+export const pgOrchestraDreams = pgTable("orchestra_dreams", {
+  dreamId: text("dream_id").primaryKey(),
+  title: text("title").notNull(),
+  status: text("status").notNull(),
+  ownerActorId: text("owner_actor_id").notNull(),
+  priority: integer("priority").notNull(),
+  metadata: pgJson("metadata"),
+  createdAt: pgCreated("created_at"),
+  updatedAt: pgCreated("updated_at"),
+});
+
+export const pgOrchestraTasks = pgTable("orchestra_tasks", {
+  taskId: text("task_id").primaryKey(),
+  dreamId: text("dream_id"),
+  assigneeAgentId: text("assignee_agent_id").notNull(),
+  status: text("status").notNull(),
+  input: pgJson("input"),
+  requiredScopes: pgJson("required_scopes"),
+  createdAt: pgCreated("created_at"),
+  updatedAt: pgCreated("updated_at"),
+});
+
+export const pgOrchestraRuns = pgTable("orchestra_runs", {
+  runId: text("run_id").primaryKey(),
+  taskId: text("task_id").notNull(),
+  agentId: text("agent_id").notNull(),
+  status: text("status").notNull(),
+  attempt: integer("attempt").notNull(),
+  startedAt: pgCreated("started_at"),
+  completedAt: pgOptionalTime("completed_at"),
+  metadata: pgJson("metadata"),
+});
+
+export const pgOrchestraRunEvents = pgTable("orchestra_run_events", {
+  eventId: text("event_id").primaryKey(),
+  runId: text("run_id").notNull(),
+  eventType: text("event_type").notNull(),
+  sequence: integer("sequence").notNull(),
+  payload: pgJson("payload"),
+  recordedAt: pgCreated("recorded_at"),
+});
+
+export const pgOrchestraToolCalls = pgTable("orchestra_tool_calls", {
+  toolCallId: text("tool_call_id").primaryKey(),
+  runId: text("run_id").notNull(),
+  toolName: text("tool_name").notNull(),
+  risk: text("risk").notNull(),
+  status: text("status").notNull(),
+  inputRef: text("input_ref").notNull(),
+  outputRef: text("output_ref"),
+  createdAt: pgCreated("created_at"),
+});
+
+export const pgOrchestraArtifacts = pgTable("orchestra_artifacts", {
+  artifactId: text("artifact_id").primaryKey(),
+  runId: text("run_id").notNull(),
+  kind: text("kind").notNull(),
+  uri: text("uri").notNull(),
+  provenance: pgJson("provenance"),
+  createdAt: pgCreated("created_at"),
+});
+
+export const pgOrchestraGrants = pgTable("orchestra_grants", {
+  grantId: text("grant_id").primaryKey(),
+  subjectActorId: text("subject_actor_id").notNull(),
+  scope: text("scope").notNull(),
+  resourceRef: text("resource_ref").notNull(),
+  status: text("status").notNull(),
+  expiresAt: pgOptionalTime("expires_at"),
+  createdAt: pgCreated("created_at"),
+});
+
+export const pgOrchestraApprovals = pgTable("orchestra_approvals", {
+  approvalId: text("approval_id").primaryKey(),
+  runId: text("run_id").notNull(),
+  actionId: text("action_id").notNull(),
+  requestedBy: text("requested_by").notNull(),
+  decidedBy: text("decided_by"),
+  status: text("status").notNull(),
+  requiredScopes: pgJson("required_scopes"),
+  requestedAt: pgCreated("requested_at"),
+  decidedAt: pgOptionalTime("decided_at"),
+  expiresAt: pgOptionalTime("expires_at"),
+});
+
+export const pgOrchestraSecrets = pgTable("orchestra_secrets", {
+  secretId: text("secret_id").primaryKey(),
+  name: text("name").notNull(),
+  keyVersionId: text("key_version_id").notNull(),
+  sealedPayload: pgJson("sealed_payload"),
+  metadata: pgJson("metadata"),
+  createdAt: pgCreated("created_at"),
+  rotatedAt: pgOptionalTime("rotated_at"),
+});
+
+export const pgOrchestraSecretKeyVersions = pgTable("orchestra_secret_key_versions", {
+  keyVersionId: text("key_version_id").primaryKey(),
+  status: text("status").notNull(),
+  algorithm: text("algorithm").notNull(),
+  createdAt: pgCreated("created_at"),
+  retiredAt: pgOptionalTime("retired_at"),
+  rotationPolicy: pgJson("rotation_policy"),
+});
+
+export const pgOrchestraAuditLogs = pgTable("orchestra_audit_logs", {
+  auditId: text("audit_id").primaryKey(),
+  actorId: text("actor_id").notNull(),
+  eventType: text("event_type").notNull(),
+  resourceRef: text("resource_ref").notNull(),
+  outcome: text("outcome").notNull(),
+  summary: text("summary").notNull(),
+  recordedAt: pgCreated("recorded_at"),
+  metadata: pgJson("metadata"),
+});
+
+export const libsqlOrchestraOrgDirectory = sqliteTable("orchestra_org_directory", {
+  actorId: sqliteText("actor_id").primaryKey(),
+  actorType: sqliteText("actor_type").notNull(),
+  displayName: sqliteText("display_name").notNull(),
+  status: sqliteText("status").notNull(),
+  metadata: sqliteJson("metadata"),
+  createdAt: sqliteCreated("created_at"),
+  updatedAt: sqliteCreated("updated_at"),
+});
+
+export const libsqlOrchestraAgents = sqliteTable("orchestra_agents", {
+  agentId: sqliteText("agent_id").primaryKey(),
+  directoryActorId: sqliteText("directory_actor_id").notNull(),
+  modelFamily: sqliteText("model_family").notNull(),
+  capabilities: sqliteJson("capabilities"),
+  status: sqliteText("status").notNull(),
+  createdAt: sqliteCreated("created_at"),
+  updatedAt: sqliteCreated("updated_at"),
+});
+
+export const libsqlOrchestraDreams = sqliteTable("orchestra_dreams", {
+  dreamId: sqliteText("dream_id").primaryKey(),
+  title: sqliteText("title").notNull(),
+  status: sqliteText("status").notNull(),
+  ownerActorId: sqliteText("owner_actor_id").notNull(),
+  priority: sqliteInteger("priority").notNull(),
+  metadata: sqliteJson("metadata"),
+  createdAt: sqliteCreated("created_at"),
+  updatedAt: sqliteCreated("updated_at"),
+});
+
+export const libsqlOrchestraTasks = sqliteTable("orchestra_tasks", {
+  taskId: sqliteText("task_id").primaryKey(),
+  dreamId: sqliteText("dream_id"),
+  assigneeAgentId: sqliteText("assignee_agent_id").notNull(),
+  status: sqliteText("status").notNull(),
+  input: sqliteJson("input"),
+  requiredScopes: sqliteJson("required_scopes"),
+  createdAt: sqliteCreated("created_at"),
+  updatedAt: sqliteCreated("updated_at"),
+});
+
+export const libsqlOrchestraRuns = sqliteTable("orchestra_runs", {
+  runId: sqliteText("run_id").primaryKey(),
+  taskId: sqliteText("task_id").notNull(),
+  agentId: sqliteText("agent_id").notNull(),
+  status: sqliteText("status").notNull(),
+  attempt: sqliteInteger("attempt").notNull(),
+  startedAt: sqliteCreated("started_at"),
+  completedAt: sqliteOptionalTime("completed_at"),
+  metadata: sqliteJson("metadata"),
+});
+
+export const libsqlOrchestraRunEvents = sqliteTable("orchestra_run_events", {
+  eventId: sqliteText("event_id").primaryKey(),
+  runId: sqliteText("run_id").notNull(),
+  eventType: sqliteText("event_type").notNull(),
+  sequence: sqliteInteger("sequence").notNull(),
+  payload: sqliteJson("payload"),
+  recordedAt: sqliteCreated("recorded_at"),
+});
+
+export const libsqlOrchestraToolCalls = sqliteTable("orchestra_tool_calls", {
+  toolCallId: sqliteText("tool_call_id").primaryKey(),
+  runId: sqliteText("run_id").notNull(),
+  toolName: sqliteText("tool_name").notNull(),
+  risk: sqliteText("risk").notNull(),
+  status: sqliteText("status").notNull(),
+  inputRef: sqliteText("input_ref").notNull(),
+  outputRef: sqliteText("output_ref"),
+  createdAt: sqliteCreated("created_at"),
+});
+
+export const libsqlOrchestraArtifacts = sqliteTable("orchestra_artifacts", {
+  artifactId: sqliteText("artifact_id").primaryKey(),
+  runId: sqliteText("run_id").notNull(),
+  kind: sqliteText("kind").notNull(),
+  uri: sqliteText("uri").notNull(),
+  provenance: sqliteJson("provenance"),
+  createdAt: sqliteCreated("created_at"),
+});
+
+export const libsqlOrchestraGrants = sqliteTable("orchestra_grants", {
+  grantId: sqliteText("grant_id").primaryKey(),
+  subjectActorId: sqliteText("subject_actor_id").notNull(),
+  scope: sqliteText("scope").notNull(),
+  resourceRef: sqliteText("resource_ref").notNull(),
+  status: sqliteText("status").notNull(),
+  expiresAt: sqliteOptionalTime("expires_at"),
+  createdAt: sqliteCreated("created_at"),
+});
+
+export const libsqlOrchestraApprovals = sqliteTable("orchestra_approvals", {
+  approvalId: sqliteText("approval_id").primaryKey(),
+  runId: sqliteText("run_id").notNull(),
+  actionId: sqliteText("action_id").notNull(),
+  requestedBy: sqliteText("requested_by").notNull(),
+  decidedBy: sqliteText("decided_by"),
+  status: sqliteText("status").notNull(),
+  requiredScopes: sqliteJson("required_scopes"),
+  requestedAt: sqliteCreated("requested_at"),
+  decidedAt: sqliteOptionalTime("decided_at"),
+  expiresAt: sqliteOptionalTime("expires_at"),
+});
+
+export const libsqlOrchestraSecrets = sqliteTable("orchestra_secrets", {
+  secretId: sqliteText("secret_id").primaryKey(),
+  name: sqliteText("name").notNull(),
+  keyVersionId: sqliteText("key_version_id").notNull(),
+  sealedPayload: sqliteJson("sealed_payload"),
+  metadata: sqliteJson("metadata"),
+  createdAt: sqliteCreated("created_at"),
+  rotatedAt: sqliteOptionalTime("rotated_at"),
+});
+
+export const libsqlOrchestraSecretKeyVersions = sqliteTable("orchestra_secret_key_versions", {
+  keyVersionId: sqliteText("key_version_id").primaryKey(),
+  status: sqliteText("status").notNull(),
+  algorithm: sqliteText("algorithm").notNull(),
+  createdAt: sqliteCreated("created_at"),
+  retiredAt: sqliteOptionalTime("retired_at"),
+  rotationPolicy: sqliteJson("rotation_policy"),
+});
+
+export const libsqlOrchestraAuditLogs = sqliteTable("orchestra_audit_logs", {
+  auditId: sqliteText("audit_id").primaryKey(),
+  actorId: sqliteText("actor_id").notNull(),
+  eventType: sqliteText("event_type").notNull(),
+  resourceRef: sqliteText("resource_ref").notNull(),
+  outcome: sqliteText("outcome").notNull(),
+  summary: sqliteText("summary").notNull(),
+  recordedAt: sqliteCreated("recorded_at"),
+  metadata: sqliteJson("metadata"),
+});
+
+export const pgOrchestraSchema = {
+  orgDirectory: pgOrchestraOrgDirectory,
+  agents: pgOrchestraAgents,
+  dreams: pgOrchestraDreams,
+  tasks: pgOrchestraTasks,
+  runs: pgOrchestraRuns,
+  runEvents: pgOrchestraRunEvents,
+  toolCalls: pgOrchestraToolCalls,
+  artifacts: pgOrchestraArtifacts,
+  grants: pgOrchestraGrants,
+  approvals: pgOrchestraApprovals,
+  secrets: pgOrchestraSecrets,
+  secretKeyVersions: pgOrchestraSecretKeyVersions,
+  auditLogs: pgOrchestraAuditLogs,
+};
+
+export const libsqlOrchestraSchema = {
+  orgDirectory: libsqlOrchestraOrgDirectory,
+  agents: libsqlOrchestraAgents,
+  dreams: libsqlOrchestraDreams,
+  tasks: libsqlOrchestraTasks,
+  runs: libsqlOrchestraRuns,
+  runEvents: libsqlOrchestraRunEvents,
+  toolCalls: libsqlOrchestraToolCalls,
+  artifacts: libsqlOrchestraArtifacts,
+  grants: libsqlOrchestraGrants,
+  approvals: libsqlOrchestraApprovals,
+  secrets: libsqlOrchestraSecrets,
+  secretKeyVersions: libsqlOrchestraSecretKeyVersions,
+  auditLogs: libsqlOrchestraAuditLogs,
+};
+
+export const ORCHESTRA_DRIZZLE_SCHEMA = {
+  schemaVersion: ORCHESTRA_SCHEMA_VERSION,
+  tableCount: ORCHESTRA_TABLES.length,
+  dialects: {
+    postgres: pgOrchestraSchema,
+    libsql: libsqlOrchestraSchema,
+  },
+};