@opencxh/domain 1.256.0 → 1.260.0

package/dist/entities/agent/types.d.ts

@@ -1,3 +1,4 @@
+import { Autonomy } from '../playbook/types';
 /**
  * An **agent**: a digital colleague. A profile plus an identity plus a mandate.
  *
@@ -42,6 +43,15 @@ export interface Agent {
         name: string;
         policy: "read" | "write";
     }[];
+    /**
+     * Does this colleague act, or propose and wait for a human?
+     *
+     * Absent = `"suggest"`, fail-closed. On the agent because it is the plainest mandate there is,
+     * and because it has to be settable for work that has no playbook: an assignment someone typed
+     * took its autonomy from the shared "Assist" playbook, which is gone. A triggered assignment
+     * still follows its playbook — that is where an organisation configured that scenario.
+     */
+    autonomy?: Autonomy;
     /**
      * Which colleagues this agent may call in for a sub-question (agent ids).
      *

package/dist/entities/ai-message/types.d.ts

@@ -1,5 +1,6 @@
 import { AIAttachment, RejectedAIAttachment } from '../../platform/ai-attachments';
 import { ToolTraceEntry } from '../../platform/ai-tools';
+import { UserType } from '../user/types';
 export interface AIMessageInput {
     text: string;
     type: "text";
@@ -48,6 +49,37 @@ export interface AIMessage {
     output: AIMessageOutput;
     accountId?: string;
     model?: string;
+    /**
+     * The brain that produced this turn. `accountId` + `model` said *what* answered and never
+     * *who*, so "which profile wrote this" was unanswerable after the fact — and a profile people
+     * edit is exactly the thing you want to look back at when an answer was wrong.
+     *
+     * Absent on a row nobody's brain produced: a human writing in an assignment thread.
+     */
+    profileId?: string;
+    /** The agent whose turn this was, when it was an agent's. Absent for the assistant. */
+    agentId?: string;
+    /**
+     * Who put this row in the thread, when it was somebody rather than the assistant.
+     *
+     * **The shape `getUserProfile` returns**, deliberately: `type` is the existing answer to
+     * "human or agent" ({@link UserType}) and inventing a second author vocabulary for one screen
+     * is how this codebase ended up asking "is this a message?" in six places.
+     *
+     * Why it has to be stored: an answer from a colleague-agent arrives as `sender: "user"` — it
+     * *is* the user turn of the next model call — so after a reload it read exactly like an
+     * instruction from the person who gave the assignment. The difference between material to
+     * weigh and an order to follow lived only in the wake note, which is not persisted.
+     *
+     * `type` is required here even though it is optional on a user record: every writer of this
+     * field knows which of the two it is, and "unknown" is precisely the answer that would make
+     * the field pointless.
+     */
+    author?: {
+        id: string;
+        name: string;
+        type: UserType;
+    };
     externalId?: string;
     /** Tools the assistant invoked while producing this message (final, persisted trace). */
     toolTrace?: ToolTraceEntry[];

package/dist/entities/assignment/types.d.ts

@@ -49,16 +49,25 @@ export interface Assignment {
     organizationId: string;
     /** The agent doing this: the `userId` of a user with `type: "agent"`. */
     agentId: string;
-    /** The definition this assignment came from (a playbook with a procedure). */
-    jobId: string;
     /**
-     * The version it started on — purely for the audit.
+     * The playbook this assignment came from, when a trigger put it down. **Absent when someone
+     * typed it**, which is the common case in Assist.
+     *
+     * It used to be required, so a typed request had to invent a definition to be allowed to exist:
+     * one org-wide "Assist" playbook with an empty procedure, created on first use and rewritten on
+     * every start and every delegation. A shared mutable row behind a foreign key — and a turn read
+     * its agent off it, so one delegation could hand every other running assignment to a different
+     * agent. The row is gone; what a typed assignment needs, it now carries itself.
+     */
+    jobId?: string;
+    /**
+     * The version it started on — purely for the audit. Absent with {@link Assignment.jobId}.
      *
      * Every **turn** pins its own procedure (`run.decider`), so improved prose arrives on the next
      * turn without a running turn switching instructions mid-flight. Pinning forever would mean a
      * correction never arrives; not pinning would mean a turn changes halfway.
      */
-    jobVersion: number;
+    jobVersion?: number;
     /** What this assignment is about. Absent = work without a resource (a rollup, a chore). */
     subjectKind?: string;
     subjectId?: string;
@@ -79,6 +88,15 @@ export interface Assignment {
      * triggered one may not. The list needs to tell them apart, so it is stored.
      */
     origin?: "trigger" | "user";
+    /**
+     * Allowed tools for this assignment, narrowing-only against the agent's brain — the same rule
+     * `Procedure.tools` carries. Absent = whatever the brain allows.
+     *
+     * `POST assignment/start` has always accepted and validated this, and then dropped it on the
+     * floor: there was nowhere to put it, because the bounds lived on the shared playbook that
+     * every assignment in the organisation had to share.
+     */
+    tools?: string[];
     /**
      * The assignment that delegated this one, when an agent asked a colleague-agent a sub-question.
      * The return address: `applyTurn` reports back here the moment this assignment goes terminal.

package/dist/entities/playbook/types.d.ts

@@ -439,8 +439,13 @@ export type StartedBy =
 export interface PlaybookRun {
     id: string;
     organizationId: string;
-    playbookId: string;
-    playbookVersion: number;
+    /**
+     * The definition this run is of. **Absent on a turn of a typed assignment**: that work has no
+     * playbook, and inventing one so this column could stay required is exactly what the shared
+     * "Assist" row was.
+     */
+    playbookId?: string;
+    playbookVersion?: number;
     /**
      * The assignment this is a **turn** of, if any. Absent = a standalone execution (an
      * automation that fires and is done). Present = one move in work that outlives this run,

package/dist/platform/communication.d.ts

@@ -28,7 +28,14 @@ export interface Session {
      */
     externalId?: string;
     ui: {
-        canvas: FederatedResourceRef;
+        /**
+         * What this transport draws in the call surface — a video plane, a meeting
+         * grid. Optional: an audio-only call has no picture, and the shell renders
+         * the call timeline (events, captions, assistant cards) either way. A
+         * provider that declares one gets it *above* that timeline, never instead
+         * of it.
+         */
+        canvas?: FederatedResourceRef;
         actionTray?: FederatedResourceRef;
     };
 }
@@ -151,7 +158,8 @@ export type TransportConfig = {
     kind: "session";
     accountSelector: AccountSelector;
     ui: {
-        canvas: `${string}:${string}`;
+        /** See `Session.ui.canvas` — optional, a transport need not draw a picture. */
+        canvas?: `${string}:${string}`;
         actionTray?: `${string}:${string}`;
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opencxh/domain",
-  "version": "1.256.0",
+  "version": "1.260.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",