@jini-ai/cms 0.3.10 → 0.4.0

package/dist/workspace/agent-tools.d.ts

@@ -1,62 +1,4 @@
-/**
- * @file The Workspace domain's agent-tool catalog, instantiating this package's shared
- * naming/callability convention (the same shape every other domain catalog in this package
- * already uses).
- *
- * Purpose:
- * A static, in-process catalog describing every agent-callable tool this domain exposes and the
- * permission each one carries. This is the highest-stakes domain wired so far: a host's
- * `workspaceId` is fixed at process composition (a v1 install always has exactly one addressable
- * workspace row), so `create`/`delete` are deliberately excluded
- * outright rather than treated as ordinary CRUD:
- * - `CREATE_WORKSPACE` inserts a row no route can ever address afterwards (every other workspace
- *   route resolves strictly against the boot-wired `workspaceId`, never a caller-supplied id)
- *   — wiring it would let an agent mint permanently orphaned, unreferenceable rows with no
- *   corresponding read/delete path back to them. Zero utility, non-zero clutter/spam surface.
- * - `DELETE_WORKSPACE` is INV-03-guarded to always refuse in v1 (there is only ever one row), but
- *   the moment that guard's precondition changes (a second addressable workspace exists), the same
- *   tool becomes a lever that can remove the only workspace scope a request can reach — whole-scope,
- *   no per-domain undo, the same blast-radius class as a forward database migration or a backup
- *   restore. Excluded by design, mirroring those two.
- * `UPDATE_WORKSPACE` is the one write kept: a narrow rename of `name`/`slug` on the single existing,
- * already-addressable workspace, no cascading effects (`id`/`createdAt` immutable by convention —
- * see `update.ts`), the same risk class as `identity_role_rename`.
- *
- * How it relates to the package:
- * A host's server-side tool filter consumes this catalog to decide which tool names an
- * agent session may even see; `authorize()` (the single-evaluator rule below) enforces the actual
- * permission checks at call time — this module only declares the catalog shape, it performs no
- * I/O and no enforcement itself.
- *
- * Architectural role:
- * `workspace` domain logic. No dependencies.
- */
-export type AgentToolSideEffect = "none" | "mutates-durable-state" | "mints-token";
-export type AgentToolActorClassRule = "confirmer-must-equal-own-delegatedBy" | "user-only" | "none";
-export interface AgentToolDefinition {
-    name: string;
-    description: string;
-    sideEffects: AgentToolSideEffect;
-    authorization: {
-        permission: string;
-    };
-    actorClassRule?: AgentToolActorClassRule;
-    /**
-     * JSON Schema for this tool's `input`, published to the model via `ToolDescriptor.inputSchema`
-     * by whichever host layer wires these tools (any such layer should refuse to wire a tool lacking
-     * one). Optional, matching this package's other domain catalogs — the two entries this dispatch
-     * leaves unwired (see file header) carry no schema at all, since one is never published for a
-     * tool the model never sees.
-     *
-     * Deliberately not widened to `| undefined` (unlike most optional fields in this port) — this
-     * type flows into `core/tools/registration-kit.ts`'s `WirableToolDefinition`, which declares both
-     * this field and `actorClassRule` above without `| undefined`. Widening only this catalog's copy
-     * would make it structurally incompatible with that shared interface under
-     * `exactOptionalPropertyTypes`, the same reason `navigation`'s and `identity`'s catalogs leave
-     * these two fields alone.
-     */
-    inputSchema?: Readonly<Record<string, unknown>>;
-}
+import type { AgentToolDefinition } from "@jini-ai/core";
 /**
  * The Workspace domain's fixed agent-tool catalog.
  *

package/dist/workspace/agent-tools.js

@@ -10,28 +10,43 @@
  * workspace row), so `create`/`delete` are deliberately excluded
  * outright rather than treated as ordinary CRUD:
  * - `CREATE_WORKSPACE` inserts a row no route can ever address afterwards (every other workspace
- *   route resolves strictly against the boot-wired `workspaceId`, never a caller-supplied id)
- *   — wiring it would let an agent mint permanently orphaned, unreferenceable rows with no
- *   corresponding read/delete path back to them. Zero utility, non-zero clutter/spam surface.
- * - `DELETE_WORKSPACE` is INV-03-guarded to always refuse in v1 (there is only ever one row), but
- *   the moment that guard's precondition changes (a second addressable workspace exists), the same
- *   tool becomes a lever that can remove the only workspace scope a request can reach — whole-scope,
- *   no per-domain undo, the same blast-radius class as a forward database migration or a backup
- *   restore. Excluded by design, mirroring those two.
+ * route resolves strictly against the boot-wired `workspaceId`, never a caller-supplied id)
+ * — wiring it would let an agent mint permanently orphaned, unreferenceable rows with no
+ * corresponding read/delete path back to them. Zero utility, non-zero clutter/spam surface.
+ * - `DELETE_WORKSPACE` is -guarded to always refuse in v1 (there is only ever one row), but
+ * the moment that guard's precondition changes (a second addressable workspace exists), the same
+ * tool becomes a lever that can remove the only workspace scope a request can reach — whole-scope,
+ * no per-domain undo, the same blast-radius class as a forward database migration or a backup
+ * restore. Excluded by design, mirroring those two.
  * `UPDATE_WORKSPACE` is the one write kept: a narrow rename of `name`/`slug` on the single existing,
  * already-addressable workspace, no cascading effects (`id`/`createdAt` immutable by convention —
  * see `update.ts`), the same risk class as `identity_role_rename`.
  *
  * How it relates to the package:
  * A host's server-side tool filter consumes this catalog to decide which tool names an
- * agent session may even see; `authorize()` (the single-evaluator rule below) enforces the actual
+ * agent session may even see; `authorize` (the single-evaluator rule below) enforces the actual
  * permission checks at call time — this module only declares the catalog shape, it performs no
  * I/O and no enforcement itself.
  *
  * Architectural role:
  * `workspace` domain logic. No dependencies.
- */
-/** No arguments — `workspace_get` takes none; it always reports the caller's own boot-wired workspace. */
+ * See docs/decisions/DR-007-workspace-and-owner-floors.md.
+ *
+ *
+   * JSON Schema for this tool's `input`, published to the model via `ToolDescriptor.inputSchema`
+   * by whichever host layer wires these tools (any such layer should refuse to wire a tool lacking
+   * one). Optional, matching this package's other domain catalogs — the two entries this dispatch
+   * leaves unwired (see file header) carry no schema at all, since one is never published for a
+   * tool the model never sees.
+   *
+   * Deliberately not widened to `| undefined` (unlike most optional fields in this port) — this
+   * type flows into `@jini-ai/core`'s `registration-kit.ts`'s `AgentToolDefinition`, which declares both
+   * this field and `actorClassRule` above without `| undefined`. Widening only this catalog's copy
+   * would make it structurally incompatible with that shared interface under
+   * `exactOptionalPropertyTypes`, the same reason `navigation`'s and `identity`'s catalogs leave
+   * these two fields alone.
+   *
+ * No arguments — `workspace_get` takes none; it always reports the caller's own boot-wired workspace. */
 const NO_INPUT_SCHEMA = {
     type: "object",
     additionalProperties: false,
@@ -88,7 +103,7 @@ export function getWorkspaceAgentToolCatalog() {
             authorization: { permission: "workspace.manage" },
         },
         {
-            // EXCLUDED BY DESIGN, never wired: see this file's header. INV-03-guarded to always refuse
+            // EXCLUDED BY DESIGN, never wired: see this file's header. -guarded to always refuse. See docs/decisions/DR-007-workspace-and-owner-floors.md.
             // today (v1 has exactly one workspace row), but the lever itself removes the only addressable
             // workspace scope the moment that guard's precondition ever changes — whole-scope,
             // irreversible, no per-domain undo. Same exclusion class as a forward database migration or a

package/dist/workspace/create.d.ts

@@ -1,4 +1,5 @@
-import type { ClockPort, IdGeneratorPort, OutboxPort, UUID } from "../core/ports.js";
+import type { Clock, IdGenerator, UUID } from "@jini-ai/core/primitives";
+import type { OutboxPort } from "../core/ports.js";
 /**
  * @file Workspace creation vertical slice (domain logic).
  *
@@ -33,8 +34,12 @@ export interface WorkspaceRecord {
  */
 export interface WorkspaceRepoPort {
     insert(record: WorkspaceRecord): Promise<void>;
-    findBySlug(slug: string): Promise<WorkspaceRecord | null>;
-    findById(id: UUID): Promise<WorkspaceRecord | null>;
+    findBySlug({ slug }: {
+        slug: string;
+    }): Promise<WorkspaceRecord | null>;
+    findById({ id }: {
+        id: UUID;
+    }): Promise<WorkspaceRecord | null>;
     /** A v1 install always has exactly one row (see `delete.ts`'s header);
      * the port itself is not limited to one. */
     list(): Promise<WorkspaceRecord[]>;
@@ -43,7 +48,15 @@ export interface WorkspaceRepoPort {
     update(record: WorkspaceRecord): Promise<void>;
     /** Callers (see `delete.ts`) must apply the last-workspace guard
      * themselves — this port method performs the row deletion only, no business rule. */
-    delete(id: UUID): Promise<void>;
+    delete({ id }: {
+        id: UUID;
+    }): Promise<void>;
+    /** Optional for existing adapters; deletion needs this or an injected transaction.
+     * Serializes the entire count/guard/delete operation against competing deletions,
+     * rolling back on rejection. Durable adapters must cover all workspace writers. */
+    transaction?<T>(required: {
+        fn: () => Promise<T>;
+    }): Promise<T>;
 }
 /**
  * Shared `name`/`slug` validation — used by both `createWorkspace` below
@@ -68,8 +81,8 @@ export interface CreateWorkspaceInput {
 }
 /** Dependencies required by the create-workspace slice. */
 export interface CreateWorkspaceDeps {
-    idGen: IdGeneratorPort;
-    clock: ClockPort;
+    idGen: IdGenerator;
+    clock: Clock;
     repo: WorkspaceRepoPort;
     outbox: OutboxPort;
 }
@@ -83,12 +96,21 @@ export interface CreateWorkspaceOptional {
 }
 /** Thrown when incoming command data is invalid. */
 export declare class WorkspaceValidationError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 /** Thrown when uniqueness constraints are violated. */
 export declare class WorkspaceConflictError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 /** Thrown when a `:workspaceId` does not resolve to a row. */
 export declare class WorkspaceNotFoundError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 /**
  * Thrown when `deleteWorkspace` (`delete.ts`) would remove the install's
@@ -98,6 +120,9 @@ export declare class WorkspaceNotFoundError extends Error {
  * from `IdentityForbiddenError` for the identical reason (typed-reason clarity).
  */
 export declare class WorkspaceLastRemainingError extends Error {
+    constructor({ message }: {
+        message: string;
+    }, optionalArgs?: ErrorOptions);
 }
 /**
  * Execute create-workspace command.

package/dist/workspace/create.js

@@ -1,3 +1,4 @@
+import { nowIso as kernelNowIso } from "@jini-ai/core/primitives";
 /**
  * Shared `name`/`slug` validation — used by both `createWorkspace` below
  * and `updateWorkspace` (`update.ts`) so the two transitions can never drift on what counts as a
@@ -11,20 +12,29 @@ export function validateWorkspaceNameAndSlug(input) {
     const name = input.name.trim();
     const slug = input.slug.trim().toLowerCase();
     if (!name)
-        throw new WorkspaceValidationError("name is required");
+        throw new WorkspaceValidationError({ message: "name is required" });
     if (!slug.match(/^[a-z0-9-]+$/)) {
-        throw new WorkspaceValidationError("slug must use lowercase letters, numbers, and dashes");
+        throw new WorkspaceValidationError({ message: "slug must use lowercase letters, numbers, and dashes" });
     }
     return { name, slug };
 }
 /** Thrown when incoming command data is invalid. */
 export class WorkspaceValidationError extends Error {
+    constructor({ message }, optionalArgs = {}) {
+        super(message, optionalArgs);
+    }
 }
 /** Thrown when uniqueness constraints are violated. */
 export class WorkspaceConflictError extends Error {
+    constructor({ message }, optionalArgs = {}) {
+        super(message, optionalArgs);
+    }
 }
 /** Thrown when a `:workspaceId` does not resolve to a row. */
 export class WorkspaceNotFoundError extends Error {
+    constructor({ message }, optionalArgs = {}) {
+        super(message, optionalArgs);
+    }
 }
 /**
  * Thrown when `deleteWorkspace` (`delete.ts`) would remove the install's
@@ -34,6 +44,9 @@ export class WorkspaceNotFoundError extends Error {
  * from `IdentityForbiddenError` for the identical reason (typed-reason clarity).
  */
 export class WorkspaceLastRemainingError extends Error {
+    constructor({ message }, optionalArgs = {}) {
+        super(message, optionalArgs);
+    }
 }
 /**
  * Execute create-workspace command.
@@ -49,10 +62,10 @@ export class WorkspaceLastRemainingError extends Error {
 export async function createWorkspace(required, _optional = {}) {
     const { deps, input } = required;
     const { name, slug } = validateWorkspaceNameAndSlug(input);
-    const existing = await deps.repo.findBySlug(slug);
+    const existing = await deps.repo.findBySlug({ slug: slug });
     if (existing)
-        throw new WorkspaceConflictError(`slug '${slug}' already exists`);
-    const now = deps.clock.nowIso();
+        throw new WorkspaceConflictError({ message: `slug '${slug}' already exists` });
+    const now = kernelNowIso({ clock: deps.clock });
     const id = deps.idGen.newId();
     await deps.repo.insert({ id, name, slug, createdAt: now });
     const event = {

package/dist/workspace/delete.d.ts

@@ -1,4 +1,5 @@
-import type { UUID } from "../core/ports.js";
+import type { TransactionalRepoPort } from "../taxonomy/write-service.js";
+import type { UUID } from "@jini-ai/core/primitives";
 import { type WorkspaceRepoPort } from "./create.js";
 /**
  * @file `DELETE_WORKSPACE` — hard-delete a workspace, guarded so the
@@ -13,14 +14,15 @@ import { type WorkspaceRepoPort } from "./create.js";
  * works without further design.
  *
  * Architectural role:
- * Ordinary slice function — not a port. `deps.repo.list()` is the count source; the guard
- * check and the delete happen inside one `async` function body with no `await` yielded to another
- * caller in between the count read and the delete write, which — under a single Node.js
- * event-loop, no-concurrent-DB-transaction execution model (the same "atomic by construction"
- * reasoning `identity/grant-service.ts`'s own header comment documents for its transitions, and the
- * same model `DISABLE_PRINCIPAL`'s INV-08 count-check-then-disable already relies on) — is the
- * atomicity INV-03 requires. A future multi-process/multi-connection deployment would need a real
- * DB-level transaction here; flagged, not silently assumed away.
+ * Ordinary slice function — not a port. `deps.repo.list` is the count source; the guard
+ * check and the delete run in one transaction. The earlier single-Node-event-loop,
+ * "atomic by construction" reasoning (also used for `identity/grant-service.ts`'s transitions
+ * and `DISABLE_PRINCIPAL`'s count-check-then-disable) was insufficient: awaits can
+ * interleave even in one process. needs serialization across the count read and delete.
+ * The memory adapter queues transactions; a multi-process/multi-connection deployment needs
+ * a DB-level transaction that serializes all workspace writers, supplied by the host.
+ * Without the required transaction port, deletion fails closed before repository reads.
+ * See docs/decisions/DR-007-workspace-and-owner-floors.md.
  */
 /** Command payload for `DELETE_WORKSPACE`. */
 export interface DeleteWorkspaceInput {
@@ -29,6 +31,8 @@ export interface DeleteWorkspaceInput {
 /** Dependencies required by the delete-workspace slice. */
 export interface DeleteWorkspaceDeps {
     repo: WorkspaceRepoPort;
+    /** Required transaction; must serialize workspace writers on its store. */
+    transaction: TransactionalRepoPort["transaction"];
 }
 /** Required parameters for `deleteWorkspace`. */
 export interface DeleteWorkspaceRequired {
@@ -36,15 +40,16 @@ export interface DeleteWorkspaceRequired {
     input: DeleteWorkspaceInput;
 }
 /**
- * Execute `DELETE_WORKSPACE` (REQ-05). Throws `WorkspaceNotFoundError` if `input.id` does not
- * resolve to a row, else `WorkspaceLastRemainingError` (INV-03) if it is the only workspace row —
+ * Execute `DELETE_WORKSPACE`. Throws `WorkspaceNotFoundError` if `input.id` does not
+ * resolve to a row, else `WorkspaceLastRemainingError` if it is the only workspace row —
  * which is always true in v1, so this transition always refuses today. No row is deleted on either
  * rejection.
  *
- * @complexity O(n) in the total workspace count (`repo.list()`) — bounded by the same
- * operator-managed-roster assumption `identity`'s `PrincipalRepoPort.list()` already makes; not a
+ * @complexity O(n) in the total workspace count (`repo.list`) — bounded by the same
+ * operator-managed-roster assumption `identity`'s `PrincipalRepoPort.list` already makes; not a
  * caller-controlled collection.
  * @overallScore 100
+ * See docs/decisions/DR-007-workspace-and-owner-floors.md.
  */
 export declare function deleteWorkspace(required: DeleteWorkspaceRequired): Promise<void>;
 //# sourceMappingURL=delete.d.ts.map

package/dist/workspace/delete.js

@@ -1,24 +1,32 @@
 import { WorkspaceLastRemainingError, WorkspaceNotFoundError } from "./create.js";
 /**
- * Execute `DELETE_WORKSPACE` (REQ-05). Throws `WorkspaceNotFoundError` if `input.id` does not
- * resolve to a row, else `WorkspaceLastRemainingError` (INV-03) if it is the only workspace row —
+ * Execute `DELETE_WORKSPACE`. Throws `WorkspaceNotFoundError` if `input.id` does not
+ * resolve to a row, else `WorkspaceLastRemainingError` if it is the only workspace row —
  * which is always true in v1, so this transition always refuses today. No row is deleted on either
  * rejection.
  *
- * @complexity O(n) in the total workspace count (`repo.list()`) — bounded by the same
- * operator-managed-roster assumption `identity`'s `PrincipalRepoPort.list()` already makes; not a
+ * @complexity O(n) in the total workspace count (`repo.list`) — bounded by the same
+ * operator-managed-roster assumption `identity`'s `PrincipalRepoPort.list` already makes; not a
  * caller-controlled collection.
  * @overallScore 100
+ * See docs/decisions/DR-007-workspace-and-owner-floors.md.
  */
 export async function deleteWorkspace(required) {
     const { deps, input } = required;
-    const existing = await deps.repo.findById(input.id);
-    if (!existing)
-        throw new WorkspaceNotFoundError(`workspace '${input.id}' was not found`);
-    const all = await deps.repo.list();
-    if (all.length <= 1) {
-        throw new WorkspaceLastRemainingError("the install's last remaining workspace cannot be deleted (INV-03)");
-    }
-    await deps.repo.delete(input.id);
+    const transaction = deps.transaction;
+    if (!transaction)
+        throw new Error("workspace deletion requires a transaction port");
+    const guardedDelete = async () => {
+        const existing = await deps.repo.findById({ id: input.id });
+        if (!existing)
+            throw new WorkspaceNotFoundError({ message: `workspace '${input.id}' was not found` });
+        const all = await deps.repo.list();
+        if (all.length <= 1) {
+            // See docs/decisions/DR-007-workspace-and-owner-floors.md for the invariant behind this refusal; keep external identifiers out of caller-facing messages.
+            throw new WorkspaceLastRemainingError({ message: "the install's last remaining workspace cannot be deleted" });
+        }
+        await deps.repo.delete({ id: input.id });
+    };
+    await transaction({ fn: guardedDelete });
 }
 //# sourceMappingURL=delete.js.map

package/dist/workspace/index.d.ts

@@ -9,7 +9,7 @@ export { updateWorkspace, type UpdateWorkspaceDeps, type UpdateWorkspaceInput, t
 export { deleteWorkspace, type DeleteWorkspaceDeps, type DeleteWorkspaceInput, type DeleteWorkspaceRequired, } from "./delete.js";
 export { InMemoryWorkspaceRepo } from "./repo.memory.js";
 /** The agent-tool surface for this domain (see `agent-tools.ts` for what is deliberately omitted). */
-export { getWorkspaceAgentToolCatalog, type AgentToolDefinition as WorkspaceAgentToolDefinition, type AgentToolSideEffect as WorkspaceAgentToolSideEffect, type AgentToolActorClassRule as WorkspaceAgentToolActorClassRule, } from "./agent-tools.js";
+export { getWorkspaceAgentToolCatalog, } from "./agent-tools.js";
 /**
  * The agent-tool wiring for this domain.
  *

package/dist/workspace/repo.memory.d.ts

@@ -17,18 +17,33 @@ import type { WorkspaceRecord, WorkspaceRepoPort } from "./create.js";
 export declare class InMemoryWorkspaceRepo implements WorkspaceRepoPort {
     /** Internal record storage. */
     private rows;
-    constructor(initialRows?: WorkspaceRecord[]);
+    private transactionTail;
+    constructor(requiredArgs: Record<string, never>, optionalArgs?: {
+        initialRows?: WorkspaceRecord[];
+    });
     /** Insert one workspace record. */
     insert(record: WorkspaceRecord): Promise<void>;
     /** Find workspace by unique slug. */
-    findBySlug(slug: string): Promise<WorkspaceRecord | null>;
+    findBySlug({ slug }: {
+        slug: string;
+    }): Promise<WorkspaceRecord | null>;
     /** Find workspace by id. */
-    findById(id: string): Promise<WorkspaceRecord | null>;
+    findById({ id }: {
+        id: string;
+    }): Promise<WorkspaceRecord | null>;
     /** All workspace rows (v1 always has exactly one — see `delete.ts`'s header). */
     list(): Promise<WorkspaceRecord[]>;
     /** Replace the row matching `record.id` in place. */
     update(record: WorkspaceRecord): Promise<void>;
     /** Remove the row matching `id`, if present (idempotent). */
-    delete(id: string): Promise<void>;
+    delete({ id }: {
+        id: string;
+    }): Promise<void>;
+    /** Serializes transactions on this instance, restoring rows on failure. Non-reentrant:
+     * callers must put every competing guarded deletion through this seam. Direct repo writes
+     * do not join or wait for it; this local adapter supplies no cross-process isolation. */
+    transaction<T>({ fn }: {
+        fn: () => Promise<T>;
+    }): Promise<T>;
 }
 //# sourceMappingURL=repo.memory.d.ts.map

package/dist/workspace/repo.memory.js

@@ -16,7 +16,9 @@
 export class InMemoryWorkspaceRepo {
     /** Internal record storage. */
     rows;
-    constructor(initialRows = []) {
+    transactionTail = Promise.resolve();
+    constructor(requiredArgs, optionalArgs = {}) {
+        const { initialRows = [] } = optionalArgs;
         this.rows = [...initialRows];
     }
     /** Insert one workspace record. */
@@ -24,11 +26,11 @@ export class InMemoryWorkspaceRepo {
         this.rows.push(record);
     }
     /** Find workspace by unique slug. */
-    async findBySlug(slug) {
+    async findBySlug({ slug }) {
         return this.rows.find((row) => row.slug === slug) ?? null;
     }
     /** Find workspace by id. */
-    async findById(id) {
+    async findById({ id }) {
         return this.rows.find((row) => row.id === id) ?? null;
     }
     /** All workspace rows (v1 always has exactly one — see `delete.ts`'s header). */
@@ -43,8 +45,28 @@ export class InMemoryWorkspaceRepo {
         this.rows[index] = record;
     }
     /** Remove the row matching `id`, if present (idempotent). */
-    async delete(id) {
+    async delete({ id }) {
         this.rows = this.rows.filter((row) => row.id !== id);
     }
+    /** Serializes transactions on this instance, restoring rows on failure. Non-reentrant:
+     * callers must put every competing guarded deletion through this seam. Direct repo writes
+     * do not join or wait for it; this local adapter supplies no cross-process isolation. */
+    async transaction({ fn }) {
+        const previous = this.transactionTail;
+        let release;
+        this.transactionTail = new Promise((resolve) => { release = resolve; });
+        await previous;
+        const before = this.rows.map((row) => ({ ...row }));
+        try {
+            return await fn();
+        }
+        catch (error) {
+            this.rows = before;
+            throw error;
+        }
+        finally {
+            release();
+        }
+    }
 }
 //# sourceMappingURL=repo.memory.js.map

package/dist/workspace/tool-registrations.d.ts

@@ -14,13 +14,13 @@
  * `workspace.manage` check.
  */
 import type { AuthorizeFn } from "../core/commands/command.js";
-import { type DerivedRiskByToolId, type ToolRegistration } from "../core/tools/registration-kit.js";
+import { type DerivedRiskByToolId, type ToolRegistration } from "@jini-ai/core";
 import type { WorkspaceRepoPort } from "./create.js";
 /**
  * The exact slice of a host's route-deps bag Workspace's tool handlers read. Declared structurally
  * (rather than importing any host's `RouteDeps`) so this module carries no back-edge into a
  * composition root. A host satisfies this structurally by passing its existing deps object;
- * nothing there changes.
+ * hosts bind the declared repository and authorization ports.
  */
 export interface WorkspaceToolDeps {
     authorize: AuthorizeFn;

package/dist/workspace/tool-registrations.js

@@ -1,7 +1,8 @@
-import { buildDomainRegistrations, indexCatalogById, optionalString, requireInputRecord, requireNoInput, requireToolPermission, } from "../core/tools/registration-kit.js";
+import { buildDomainRegistrations, indexCatalogById, optionalString, requireInputRecord, requireNoInput } from "@jini-ai/core";
+import { adaptLegacyAuthorize, requireToolPermission } from "../core/tools/index.js";
 import { getWorkspaceAgentToolCatalog } from "./agent-tools.js";
 import { updateWorkspace } from "./update.js";
-const CATALOG_BY_ID = indexCatalogById(getWorkspaceAgentToolCatalog());
+const CATALOG_BY_ID = indexCatalogById({ catalog: getWorkspaceAgentToolCatalog() });
 /**
  * This wiring layer's OWN risk classification, authored from what each handler below actually
  * calls. See `DerivedRiskByToolId` in the kit for why it is independent of the catalog's own
@@ -14,7 +15,7 @@ export const workspaceDerivedRisk = new Map([
     ["workspace_get", "none"],
     // -> updateWorkspace (update.ts) -> repo.findById + repo.findBySlug + repo.update: validates,
     //    checks slug uniqueness excluding the row itself, writes. No domain event enqueued (matches
-    //    update.ts's own header: REQ-04 doesn't ask for one).
+    // update.ts's own header: doesn't ask for one). See docs/decisions/DR-007-workspace-and-owner-floors.md.
     ["workspace_update", "mutates-durable-state"],
 ]);
 /** Workspace catalog entries this pass does not wire, and why — see `./agent-tools.ts`'s own per-entry comments for the full reasoning. */
@@ -23,7 +24,7 @@ const UNWIRED_WORKSPACE_TOOL_IDS = new Set([
     // resolves strictly against the boot-wired `workspaceId`) — zero utility, non-zero
     // orphaned-row/clutter surface.
     "workspace_create",
-    // EXCLUDED BY DESIGN: INV-03-guarded to always refuse today, but the lever removes the only
+    // EXCLUDED BY DESIGN: -guarded to always refuse today, but the lever removes the only. See docs/decisions/DR-007-workspace-and-owner-floors.md.
     // addressable workspace scope the moment that guard's precondition ever changes — whole-scope,
     // no per-domain undo, same exclusion class as a forward database migration or a backup restore.
     "workspace_delete",
@@ -31,9 +32,9 @@ const UNWIRED_WORKSPACE_TOOL_IDS = new Set([
 export function buildWorkspaceRegistrations(routeDeps) {
     const handlers = {
         workspace_get: async (ctx) => {
-            requireNoInput(ctx.input);
-            await requireToolPermission(routeDeps, { principalId: ctx.principal.id, permission: "workspace.manage", entityType: "workspace" });
-            const workspace = await routeDeps.workspaceRepo.findById(routeDeps.workspaceId);
+            requireNoInput({ input: ctx.input });
+            await requireToolPermission({ authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }), workspaceId: routeDeps.workspaceId, principalId: ctx.principal.id, permission: "workspace.manage" }, { entityType: "workspace" });
+            const workspace = await routeDeps.workspaceRepo.findById({ id: routeDeps.workspaceId });
             if (!workspace) {
                 // Defensive: the boot-wired workspaceId always resolves to a real row by construction.
                 // Not an expected runtime path.
@@ -42,8 +43,8 @@ export function buildWorkspaceRegistrations(routeDeps) {
             return { workspace };
         },
         workspace_update: async (ctx) => {
-            const input = requireInputRecord(ctx.input);
-            await requireToolPermission(routeDeps, { principalId: ctx.principal.id, permission: "workspace.manage", entityType: "workspace" });
+            const input = requireInputRecord({ input: ctx.input });
+            await requireToolPermission({ authorize: adaptLegacyAuthorize({ authorize: routeDeps.authorize }), workspaceId: routeDeps.workspaceId, principalId: ctx.principal.id, permission: "workspace.manage" }, { entityType: "workspace" });
             // WorkspaceValidationError/WorkspaceConflictError/WorkspaceNotFoundError (all real `Error`
             // subclasses, see `create.ts`) propagate as-is — a `ToolExecutor` treats any thrown error as
             // a failed execution, matching every other domain's handler convention of not rewrapping
@@ -52,8 +53,8 @@ export function buildWorkspaceRegistrations(routeDeps) {
                 deps: { repo: routeDeps.workspaceRepo },
                 input: {
                     id: routeDeps.workspaceId,
-                    name: optionalString(input, "name"),
-                    slug: optionalString(input, "slug"),
+                    name: optionalString({ input, key: "name" }),
+                    slug: optionalString({ input, key: "slug" }),
                 },
             });
             return { workspace };
@@ -65,7 +66,6 @@ export function buildWorkspaceRegistrations(routeDeps) {
         catalog: CATALOG_BY_ID,
         handlers,
         derivedRisk: workspaceDerivedRisk,
-        unwiredToolIds: UNWIRED_WORKSPACE_TOOL_IDS,
-    });
+    }, { unwiredToolIds: UNWIRED_WORKSPACE_TOOL_IDS });
 }
 //# sourceMappingURL=tool-registrations.js.map

package/dist/workspace/update.d.ts

@@ -1,4 +1,4 @@
-import type { UUID } from "../core/ports.js";
+import type { UUID } from "@jini-ai/core/primitives";
 import { type WorkspaceRecord, type WorkspaceRepoPort } from "./create.js";
 /**
  * @file `UPDATE_WORKSPACE` — rename a workspace's `name` and/or `slug`.
@@ -14,7 +14,7 @@ import { type WorkspaceRecord, type WorkspaceRepoPort } from "./create.js";
  * Ordinary slice function, not a port — one implementation, the rule-of-two doesn't
  * apply to business logic, only to the repo/outbox seams it calls through `WorkspaceRepoPort`.
  */
-/** Command payload for `UPDATE_WORKSPACE`. At least one of `name`/`slug` must be present (EC-01). */
+/** Command payload for `UPDATE_WORKSPACE`. At least one of `name`/`slug` must be present. See docs/decisions/DR-007-workspace-and-owner-floors.md. */
 export interface UpdateWorkspaceInput {
     id: UUID;
     name?: string | undefined;
@@ -30,8 +30,8 @@ export interface UpdateWorkspaceRequired {
     input: UpdateWorkspaceInput;
 }
 /**
- * Execute `UPDATE_WORKSPACE` (REQ-04). At least one of `name`/`slug` must be present in the input
- * (EC-01 — an empty-object update is rejected, not a silent no-op, so a client-side bug that drops
+ * Execute `UPDATE_WORKSPACE`. At least one of `name`/`slug` must be present in the input
+ * ( — an empty-object update is rejected, not a silent no-op, so a client-side bug that drops
  * both fields fails loudly instead of masquerading as a successful save). When only one field is
  * given, the other keeps its current stored value; both are re-validated together through
  * `validateWorkspaceNameAndSlug` either way, so a `slug`-only update still catches a blank stored
@@ -39,12 +39,13 @@ export interface UpdateWorkspaceRequired {
  * rejects that, but re-validating both together — rather than only the changed field — keeps this
  * function's invariant identical to `createWorkspace`'s with no special-cased partial path).
  *
- * The slug-uniqueness check excludes the row being updated (EC-02 — a workspace is never "in
+ * The slug-uniqueness check excludes the row being updated ( — a workspace is never "in
  * conflict with itself"): `findBySlug` naturally excludes it whenever the row's own `id` matches,
  * since that's a no-op rename, not a collision with a *different* row.
  *
  * @complexity O(1) — one lookup by id, one lookup by slug, one write.
  * @overallScore 100
+ * See docs/decisions/DR-007-workspace-and-owner-floors.md.
  */
 export declare function updateWorkspace(required: UpdateWorkspaceRequired): Promise<{
     workspace: WorkspaceRecord;