@pellux/goodvibes-sdk 0.38.0 → 1.0.0

package/dist/platform/control-plane/operator-contract-schemas-fleet.js

@@ -0,0 +1,182 @@
+/**
+ * operator-contract-schemas-fleet.ts
+ *
+ * W3-S2 — contract schemas for fleet.*, checkpoints.*, and sessions.search.
+ * Split out of operator-contract-schemas-runtime.ts (which was already at
+ * the 800-line source-file cap) rather than grown into it; re-exported
+ * through operator-contract-schemas.ts alongside the other schema modules.
+ */
+import { BOOLEAN_SCHEMA, NUMBER_SCHEMA, STRING_SCHEMA, arraySchema, objectSchema, } from './method-catalog-shared.js';
+import { STRING_LIST_SCHEMA, enumSchema, nullableSchema, } from './operator-contract-schemas-shared.js';
+import { SHARED_SESSION_KIND_READ_SCHEMA, SHARED_SESSION_RECORD_SCHEMA } from './operator-contract-schemas-runtime.js';
+const PROCESS_KIND_SCHEMA = enumSchema([
+    'agent',
+    'wrfc-chain',
+    'wrfc-subtask',
+    'workflow',
+    'trigger',
+    'schedule',
+    'watcher',
+    'background-process',
+    'workstream',
+    'phase',
+    'work-item',
+    'code-index',
+]);
+const PROCESS_STATE_SCHEMA = enumSchema([
+    'thinking',
+    'executing-tool',
+    'awaiting-approval',
+    'streaming',
+    'stalled',
+    'retrying',
+    'done',
+    'failed',
+    'killed',
+    'interrupted',
+    'idle',
+    'queued',
+    'paused',
+]);
+const PROCESS_COST_STATE_SCHEMA = enumSchema(['priced', 'unpriced', 'estimated']);
+const PROCESS_USAGE_SCHEMA = objectSchema({
+    inputTokens: NUMBER_SCHEMA,
+    outputTokens: NUMBER_SCHEMA,
+    cacheReadTokens: NUMBER_SCHEMA,
+    cacheWriteTokens: NUMBER_SCHEMA,
+    reasoningTokens: NUMBER_SCHEMA,
+    llmCallCount: NUMBER_SCHEMA,
+    turnCount: NUMBER_SCHEMA,
+    toolCallCount: NUMBER_SCHEMA,
+}, ['inputTokens', 'outputTokens', 'cacheReadTokens', 'cacheWriteTokens', 'llmCallCount', 'turnCount', 'toolCallCount']);
+const PROCESS_ACTIVITY_SCHEMA = objectSchema({
+    kind: enumSchema(['tool', 'output-line', 'phase']),
+    text: STRING_SCHEMA,
+    toolName: STRING_SCHEMA,
+    at: NUMBER_SCHEMA,
+}, ['kind', 'text', 'at']);
+const PROCESS_CAPABILITIES_SCHEMA = objectSchema({
+    interruptible: BOOLEAN_SCHEMA,
+    killable: BOOLEAN_SCHEMA,
+    pausable: BOOLEAN_SCHEMA,
+    resumable: BOOLEAN_SCHEMA,
+    steerable: BOOLEAN_SCHEMA,
+}, ['interruptible', 'killable', 'pausable', 'resumable', 'steerable']);
+const PROCESS_SESSION_REF_SCHEMA = objectSchema({
+    sessionId: STRING_SCHEMA,
+    agentId: STRING_SCHEMA,
+}, []);
+export const PROCESS_NODE_SCHEMA = objectSchema({
+    id: STRING_SCHEMA,
+    kind: PROCESS_KIND_SCHEMA,
+    parentId: STRING_SCHEMA,
+    label: STRING_SCHEMA,
+    task: STRING_SCHEMA,
+    state: PROCESS_STATE_SCHEMA,
+    startedAt: NUMBER_SCHEMA,
+    completedAt: NUMBER_SCHEMA,
+    elapsedMs: NUMBER_SCHEMA,
+    usage: PROCESS_USAGE_SCHEMA,
+    model: STRING_SCHEMA,
+    provider: STRING_SCHEMA,
+    costUsd: nullableSchema(NUMBER_SCHEMA),
+    costState: PROCESS_COST_STATE_SCHEMA,
+    currentActivity: PROCESS_ACTIVITY_SCHEMA,
+    capabilities: PROCESS_CAPABILITIES_SCHEMA,
+    sessionRef: PROCESS_SESSION_REF_SCHEMA,
+}, ['id', 'kind', 'label', 'state', 'elapsedMs', 'costState', 'capabilities'], { additionalProperties: true });
+export const FLEET_SNAPSHOT_OUTPUT_SCHEMA = objectSchema({
+    capturedAt: NUMBER_SCHEMA,
+    nodes: arraySchema(PROCESS_NODE_SCHEMA),
+    truncated: BOOLEAN_SCHEMA,
+    totalCount: NUMBER_SCHEMA,
+}, ['capturedAt', 'nodes', 'truncated', 'totalCount']);
+export const FLEET_LIST_INPUT_SCHEMA = objectSchema({
+    kinds: STRING_LIST_SCHEMA,
+    states: STRING_LIST_SCHEMA,
+    limit: NUMBER_SCHEMA,
+    cursor: STRING_SCHEMA,
+}, []);
+export const FLEET_LIST_OUTPUT_SCHEMA = objectSchema({
+    items: arraySchema(PROCESS_NODE_SCHEMA),
+    nextCursor: STRING_SCHEMA,
+    hasMore: BOOLEAN_SCHEMA,
+    capturedAt: NUMBER_SCHEMA,
+}, ['items', 'hasMore', 'capturedAt']);
+const CHECKPOINT_KIND_SCHEMA = enumSchema(['turn', 'agent-run', 'manual']);
+const RETENTION_CLASS_SCHEMA = enumSchema(['short', 'standard', 'forensic']);
+export const WORKSPACE_CHECKPOINT_SCHEMA = objectSchema({
+    id: STRING_SCHEMA,
+    kind: CHECKPOINT_KIND_SCHEMA,
+    label: STRING_SCHEMA,
+    createdAt: NUMBER_SCHEMA,
+    parentId: nullableSchema(STRING_SCHEMA),
+    turnId: STRING_SCHEMA,
+    agentId: STRING_SCHEMA,
+    retentionClass: RETENTION_CLASS_SCHEMA,
+    commit: STRING_SCHEMA,
+    sizeBytes: NUMBER_SCHEMA,
+}, ['id', 'kind', 'label', 'createdAt', 'parentId', 'retentionClass', 'commit', 'sizeBytes']);
+export const CHECKPOINTS_LIST_INPUT_SCHEMA = objectSchema({
+    kind: CHECKPOINT_KIND_SCHEMA,
+    since: NUMBER_SCHEMA,
+    limit: NUMBER_SCHEMA,
+}, []);
+export const CHECKPOINTS_LIST_OUTPUT_SCHEMA = objectSchema({
+    checkpoints: arraySchema(WORKSPACE_CHECKPOINT_SCHEMA),
+}, ['checkpoints']);
+export const CHECKPOINTS_CREATE_INPUT_SCHEMA = objectSchema({
+    kind: CHECKPOINT_KIND_SCHEMA,
+    label: STRING_SCHEMA,
+    retentionClass: RETENTION_CLASS_SCHEMA,
+    turnId: STRING_SCHEMA,
+    agentId: STRING_SCHEMA,
+    paths: STRING_LIST_SCHEMA,
+}, ['kind']);
+export const CHECKPOINTS_CREATE_OUTPUT_SCHEMA = objectSchema({
+    checkpoint: nullableSchema(WORKSPACE_CHECKPOINT_SCHEMA),
+    noop: BOOLEAN_SCHEMA,
+}, ['checkpoint', 'noop']);
+export const CHECKPOINT_DIFF_SCHEMA = objectSchema({
+    from: STRING_SCHEMA,
+    to: STRING_SCHEMA,
+    files: STRING_LIST_SCHEMA,
+    unifiedDiff: STRING_SCHEMA,
+    stat: STRING_SCHEMA,
+}, ['from', 'to', 'files', 'unifiedDiff', 'stat']);
+export const CHECKPOINTS_DIFF_INPUT_SCHEMA = objectSchema({
+    a: STRING_SCHEMA,
+    b: STRING_SCHEMA,
+}, ['a']);
+export const CHECKPOINTS_DIFF_OUTPUT_SCHEMA = objectSchema({
+    diff: CHECKPOINT_DIFF_SCHEMA,
+}, ['diff']);
+export const CHECKPOINT_RESTORE_RESULT_SCHEMA = objectSchema({
+    checkpointId: STRING_SCHEMA,
+    safetyCheckpointId: nullableSchema(STRING_SCHEMA),
+    restoredFiles: STRING_LIST_SCHEMA,
+    removedFiles: STRING_LIST_SCHEMA,
+}, ['checkpointId', 'safetyCheckpointId', 'restoredFiles', 'removedFiles']);
+export const CHECKPOINTS_RESTORE_INPUT_SCHEMA = objectSchema({
+    id: STRING_SCHEMA,
+    paths: STRING_LIST_SCHEMA,
+    safetyCheckpoint: BOOLEAN_SCHEMA,
+}, ['id']);
+export const CHECKPOINTS_RESTORE_OUTPUT_SCHEMA = objectSchema({
+    result: CHECKPOINT_RESTORE_RESULT_SCHEMA,
+}, ['result']);
+export const SESSIONS_SEARCH_INPUT_SCHEMA = objectSchema({
+    query: STRING_SCHEMA,
+    project: STRING_SCHEMA,
+    kind: SHARED_SESSION_KIND_READ_SCHEMA,
+    surfaceKind: STRING_SCHEMA,
+    status: enumSchema(['active', 'closed']),
+    includeClosed: BOOLEAN_SCHEMA,
+    limit: NUMBER_SCHEMA,
+    cursor: STRING_SCHEMA,
+}, []);
+export const SESSIONS_SEARCH_OUTPUT_SCHEMA = objectSchema({
+    sessions: arraySchema(SHARED_SESSION_RECORD_SCHEMA),
+    nextCursor: STRING_SCHEMA,
+    hasMore: BOOLEAN_SCHEMA,
+}, ['sessions', 'hasMore']);

package/dist/platform/control-plane/operator-contract-schemas-permissions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator-contract-schemas-permissions.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract-schemas-permissions.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,0BAA0B,yBAAuD,CAAC;AAC/F,eAAO,MAAM,4BAA4B,yBAAoD,CAAC;AAC9F,eAAO,MAAM,sCAAsC,yBAA4D,CAAC;AAChH,eAAO,MAAM,kCAAkC,yBAAyF,CAAC;AACzI,eAAO,MAAM,8BAA8B,yBAAwE,CAAC;AAEpH,eAAO,MAAM,yCAAyC,yBAWoC,CAAC;AAE3F,eAAO,MAAM,gCAAgC,yBAO0C,CAAC;AAExF,eAAO,MAAM,iCAAiC,yBAGG,CAAC;AAElD,eAAO,MAAM,sBAAsB,yBAMjC,CAAC;AACH,eAAO,MAAM,wCAAwC,yBAQnD,CAAC;AACH,eAAO,MAAM,kCAAkC,yBAAiD,CAAC;AACjG,eAAO,MAAM,8BAA8B,yBAOzC,CAAC;AACH,eAAO,MAAM,iCAAiC,yBAc5C,CAAC;AAEH,eAAO,MAAM,kCAAkC,yBAasG,CAAC"}
+{"version":3,"file":"operator-contract-schemas-permissions.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract-schemas-permissions.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,0BAA0B,yBAAuD,CAAC;AAC/F,eAAO,MAAM,4BAA4B,yBAAoD,CAAC;AAC9F,eAAO,MAAM,sCAAsC,yBAA4D,CAAC;AAChH,eAAO,MAAM,kCAAkC,yBAAyF,CAAC;AACzI,eAAO,MAAM,8BAA8B,yBAAwE,CAAC;AAEpH,eAAO,MAAM,yCAAyC,yBAWoC,CAAC;AAE3F,eAAO,MAAM,gCAAgC,yBAO0C,CAAC;AAExF,eAAO,MAAM,iCAAiC,yBAQG,CAAC;AAElD,eAAO,MAAM,sBAAsB,yBAMjC,CAAC;AACH,eAAO,MAAM,wCAAwC,yBAQnD,CAAC;AACH,eAAO,MAAM,kCAAkC,yBAAiD,CAAC;AACjG,eAAO,MAAM,8BAA8B,yBAOzC,CAAC;AACH,eAAO,MAAM,iCAAiC,yBAc5C,CAAC;AAEH,eAAO,MAAM,kCAAkC,yBAasG,CAAC"}

package/dist/platform/control-plane/operator-contract-schemas-permissions.js

@@ -28,6 +28,11 @@ export const PERMISSION_PROMPT_REQUEST_SCHEMA = objectSchema({
 export const PERMISSION_PROMPT_DECISION_SCHEMA = objectSchema({
     approved: BOOLEAN_SCHEMA,
     remember: BOOLEAN_SCHEMA,
+    // Present when a per-hunk (or otherwise argument-modifying) approval replaced
+    // the tool call's original args — e.g. the edit-tool `edits` array filtered to
+    // the approved hunks. Computed server-side by the approval broker so every
+    // surface sees the same modified args on the resolved decision.
+    modifiedArgs: TOOL_ARGUMENTS_SCHEMA,
 }, ['approved'], { additionalProperties: false });
 export const PERMISSION_MODE_SCHEMA = enumSchema([
     'default',

package/dist/platform/control-plane/operator-contract-schemas-runtime.d.ts

@@ -1,4 +1,24 @@
+/**
+ * READ-path kind schema: an OPEN enum. The known kinds are the same set as
+ * {@link SHARED_SESSION_KIND_SCHEMA}, but response/output validation must accept
+ * an unknown `kind` string per-record instead of hard-failing the whole envelope
+ * — a mixed-version daemon (or a future build) can emit a kind this reader does
+ * not model, and the tolerant normalizer downstream (`normalizeSharedSessionRecord`)
+ * already maps an unknown kind to the documented 'tui' fallback while preserving
+ * the raw value under `metadata.wireKind`. See
+ * docs/decisions/2026-07-05-session-wire-mixed-version.md (the enum leg). Writes
+ * stay strict: {@link SHARED_SESSION_REGISTER_INPUT_SCHEMA} keeps the closed enum
+ * so `sessions.register` still 400s on an unknown kind.
+ */
+export declare const SHARED_SESSION_KIND_READ_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_PARTICIPANT_SCHEMA: Record<string, unknown>;
+/**
+ * Input to sessions.register — the idempotent registration + heartbeat upsert
+ * keyed on the caller-supplied `sessionId`. Carries the identity spine
+ * (kind + project + participant triple). Re-calling with the same id is the
+ * heartbeat (advances participant.lastSeenAt).
+ */
+export declare const SHARED_SESSION_REGISTER_INPUT_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_MESSAGE_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_RECORD_SCHEMA: Record<string, unknown>;
 export declare const COMPANION_CHAT_SESSION_SCHEMA: Record<string, unknown>;
@@ -13,6 +33,14 @@ export declare const SESSION_BROKER_SNAPSHOT_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_WITH_MESSAGES_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_WITH_INPUTS_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_CREATE_OUTPUT_SCHEMA: Record<string, unknown>;
+/**
+ * Output of sessions.register. Beyond the record it carries honest lifecycle
+ * disposition: `reopened` is true only when this call reopened a closed session,
+ * and `conflict` is present (status:'closed') when register targeted a closed
+ * session WITHOUT reopen:true — the heartbeat was recorded but the session was
+ * left closed.
+ */
+export declare const SHARED_SESSION_REGISTER_OUTPUT_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_CONVERSATION_ROUTE_OUTPUT_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_MESSAGE_CREATE_OUTPUT_SCHEMA: Record<string, unknown>;
 export declare const SHARED_SESSION_MESSAGE_ROUTE_OUTPUT_SCHEMA: {
@@ -28,6 +56,7 @@ export declare const TASK_STATUS_OUTPUT_SCHEMA: Record<string, unknown>;
 export declare const SHARED_APPROVAL_RECORD_SCHEMA: Record<string, unknown>;
 export declare const APPROVAL_SNAPSHOT_SCHEMA: Record<string, unknown>;
 export declare const APPROVAL_ACTION_INPUT_SCHEMA: Record<string, unknown>;
+export declare const APPROVAL_APPROVE_INPUT_SCHEMA: Record<string, unknown>;
 export declare const APPROVAL_ACTION_OUTPUT_SCHEMA: Record<string, unknown>;
 export declare const PROVIDER_RUNTIME_SNAPSHOT_SCHEMA: Record<string, unknown>;
 export declare const PROVIDER_USAGE_SNAPSHOT_SCHEMA: Record<string, unknown>;

package/dist/platform/control-plane/operator-contract-schemas-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator-contract-schemas-runtime.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract-schemas-runtime.ts"],"names":[],"mappings":"AA+DA,eAAO,MAAM,iCAAiC,yBAQA,CAAC;AAE/C,eAAO,MAAM,6BAA6B,yBAasB,CAAC;AAEjE,eAAO,MAAM,4BAA4B,yBAmBqI,CAAC;AAE/K,eAAO,MAAM,6BAA6B,yBAYsF,CAAC;AAEjI,eAAO,MAAM,6BAA6B,yBAO4B,CAAC;AAEvE,eAAO,MAAM,2CAA2C,yBAG7B,CAAC;AAE5B,eAAO,MAAM,mCAAmC,yBAOtB,CAAC;AAE3B,eAAO,MAAM,mCAAmC,yBAGnB,CAAC;AAE9B,eAAO,MAAM,oCAAoC,yBAkB/C,CAAC;AAEH,eAAO,MAAM,kCAAkC,yBAqB0D,CAAC;AAE1G,eAAO,MAAM,uBAAuB,yBAWoE,CAAC;AAEzG,eAAO,MAAM,8BAA8B,yBAOjB,CAAC;AAE3B,eAAO,MAAM,mCAAmC,yBAGrB,CAAC;AAE5B,eAAO,MAAM,iCAAiC,yBAGrB,CAAC;AAE1B,eAAO,MAAM,mCAAmC,yBAEjC,CAAC;AAEhB,eAAO,MAAM,+CAA+C,yBAIlB,CAAC;AAE3C,eAAO,MAAM,2CAA2C,yBAMF,CAAC;AAEvD,eAAO,MAAM,0CAA0C;;CAK7C,CAAC;AAUX,eAAO,MAAM,mBAAmB,yBAqByD,CAAC;AAE1F,eAAO,MAAM,oBAAoB,yBAsBsB,CAAC;AAExD,eAAO,MAAM,wBAAwB,yBAgBO,CAAC;AAE7C,eAAO,MAAM,yBAAyB,yBASc,CAAC;AAErD,eAAO,MAAM,kBAAkB,yBAEnB,CAAC;AAEb,eAAO,MAAM,yBAAyB,yBAIM,CAAC;AAE7C,eAAO,MAAM,yBAAyB,yBAUiE,CAAC;AAWxG,eAAO,MAAM,6BAA6B,yBAgB8C,CAAC;AAEzF,eAAO,MAAM,wBAAwB,yBASuG,CAAC;AAE7I,eAAO,MAAM,4BAA4B,yBAIU,CAAC;AAEpD,eAAO,MAAM,6BAA6B,yBAE1B,CAAC;AA0EjB,eAAO,MAAM,gCAAgC,yBAMkB,CAAC;AAEhE,eAAO,MAAM,8BAA8B,yBAcqD,CAAC;AAqEjG,eAAO,MAAM,gCAAgC,yBAKmB,CAAC;AAEjE,eAAO,MAAM,sBAAsB,yBAcyF,CAAC;AAE7H,eAAO,MAAM,4BAA4B,yBASyG,CAAC;AAqBnJ,eAAO,MAAM,0BAA0B,yBAUyH,CAAC;AAEjK,eAAO,MAAM,2BAA2B,yBAIC,CAAC"}
+{"version":3,"file":"operator-contract-schemas-runtime.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract-schemas-runtime.ts"],"names":[],"mappings":"AAmCA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,+BAA+B,EAAyB,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AA6B7F,eAAO,MAAM,iCAAiC,yBAQA,CAAC;AAE/C;;;;;GAKG;AACH,eAAO,MAAM,oCAAoC,yBAOe,CAAC;AAEjE,eAAO,MAAM,6BAA6B,yBAasB,CAAC;AAEjE,eAAO,MAAM,4BAA4B,yBAuBqI,CAAC;AAE/K,eAAO,MAAM,6BAA6B,yBAYsF,CAAC;AAEjI,eAAO,MAAM,6BAA6B,yBAO4B,CAAC;AAEvE,eAAO,MAAM,2CAA2C,yBAG7B,CAAC;AAE5B,eAAO,MAAM,mCAAmC,yBAOtB,CAAC;AAE3B,eAAO,MAAM,mCAAmC,yBAGnB,CAAC;AAE9B,eAAO,MAAM,oCAAoC,yBAkB/C,CAAC;AAEH,eAAO,MAAM,kCAAkC,yBAqB0D,CAAC;AAE1G,eAAO,MAAM,uBAAuB,yBAWoE,CAAC;AAEzG,eAAO,MAAM,8BAA8B,yBAOjB,CAAC;AAE3B,eAAO,MAAM,mCAAmC,yBAGrB,CAAC;AAE5B,eAAO,MAAM,iCAAiC,yBAGrB,CAAC;AAE1B,eAAO,MAAM,mCAAmC,yBAEjC,CAAC;AAEhB;;;;;;GAMG;AACH,eAAO,MAAM,qCAAqC,yBAIvB,CAAC;AAE5B,eAAO,MAAM,+CAA+C,yBAIlB,CAAC;AAE3C,eAAO,MAAM,2CAA2C,yBAMF,CAAC;AAEvD,eAAO,MAAM,0CAA0C;;CAK7C,CAAC;AAUX,eAAO,MAAM,mBAAmB,yBAqByD,CAAC;AAE1F,eAAO,MAAM,oBAAoB,yBAsBsB,CAAC;AAExD,eAAO,MAAM,wBAAwB,yBAgBO,CAAC;AAE7C,eAAO,MAAM,yBAAyB,yBASc,CAAC;AAErD,eAAO,MAAM,kBAAkB,yBAEnB,CAAC;AAEb,eAAO,MAAM,yBAAyB,yBAIM,CAAC;AAE7C,eAAO,MAAM,yBAAyB,yBAUiE,CAAC;AAWxG,eAAO,MAAM,6BAA6B,yBAgB8C,CAAC;AAEzF,eAAO,MAAM,wBAAwB,yBASuG,CAAC;AAE7I,eAAO,MAAM,4BAA4B,yBAIU,CAAC;AAOpD,eAAO,MAAM,6BAA6B,yBAKS,CAAC;AAEpD,eAAO,MAAM,6BAA6B,yBAE1B,CAAC;AA0EjB,eAAO,MAAM,gCAAgC,yBAMkB,CAAC;AAEhE,eAAO,MAAM,8BAA8B,yBAcqD,CAAC;AAqEjG,eAAO,MAAM,gCAAgC,yBAKmB,CAAC;AAEjE,eAAO,MAAM,sBAAsB,yBAcyF,CAAC;AAE7H,eAAO,MAAM,4BAA4B,yBASyG,CAAC;AAqBnJ,eAAO,MAAM,0BAA0B,yBAUyH,CAAC;AAEjK,eAAO,MAAM,2BAA2B,yBAIC,CAAC"}

package/dist/platform/control-plane/operator-contract-schemas-runtime.js

@@ -13,10 +13,23 @@ const INBOUND_SERVER_SURFACE_SCHEMA = enumSchema(['controlPlane', 'httpListener'
 const INBOUND_TLS_MODE_SCHEMA = enumSchema(['off', 'proxy', 'direct']);
 const OUTBOUND_TRUST_MODE_SCHEMA = enumSchema(['bundled', 'bundled+custom', 'custom']);
 const OUTBOUND_CA_STRATEGY_SCHEMA = enumSchema(['bun-default', 'bundled+custom', 'custom']);
-const SHARED_SESSION_KIND_SCHEMA = enumSchema(['tui', 'companion-task', 'companion-chat']);
+const SHARED_SESSION_KIND_SCHEMA = enumSchema(['tui', 'agent', 'webui', 'companion-task', 'companion-chat', 'automation']);
+/**
+ * READ-path kind schema: an OPEN enum. The known kinds are the same set as
+ * {@link SHARED_SESSION_KIND_SCHEMA}, but response/output validation must accept
+ * an unknown `kind` string per-record instead of hard-failing the whole envelope
+ * — a mixed-version daemon (or a future build) can emit a kind this reader does
+ * not model, and the tolerant normalizer downstream (`normalizeSharedSessionRecord`)
+ * already maps an unknown kind to the documented 'tui' fallback while preserving
+ * the raw value under `metadata.wireKind`. See
+ * docs/decisions/2026-07-05-session-wire-mixed-version.md (the enum leg). Writes
+ * stay strict: {@link SHARED_SESSION_REGISTER_INPUT_SCHEMA} keeps the closed enum
+ * so `sessions.register` still 400s on an unknown kind.
+ */
+export const SHARED_SESSION_KIND_READ_SCHEMA = { type: 'string' };
 const SHARED_SESSION_INPUT_INTENT_SCHEMA = enumSchema(['submit', 'steer', 'follow-up']);
 const SHARED_SESSION_INPUT_STATE_SCHEMA = enumSchema(['queued', 'delivered', 'spawned', 'completed', 'cancelled', 'failed', 'rejected']);
-const SHARED_SESSION_MESSAGE_MODE_SCHEMA = enumSchema(['spawn', 'continued-live', 'queued-follow-up', 'rejected']);
+const SHARED_SESSION_MESSAGE_MODE_SCHEMA = enumSchema(['spawn', 'continued-live', 'queued-follow-up', 'queued-for-surface', 'rejected']);
 const COMPANION_CHAT_SESSION_STATUS_SCHEMA = enumSchema(['active', 'closed']);
 const COMPANION_CHAT_MESSAGE_ROLE_SCHEMA = enumSchema(['user', 'assistant']);
 const PROVIDER_SELECTION_SCHEMA = enumSchema(['inherit-current', 'concrete', 'synthetic']);
@@ -49,6 +62,20 @@ export const SHARED_SESSION_PARTICIPANT_SCHEMA = objectSchema({
     routeId: STRING_SCHEMA,
     lastSeenAt: NUMBER_SCHEMA,
 }, ['surfaceKind', 'surfaceId', 'lastSeenAt']);
+/**
+ * Input to sessions.register — the idempotent registration + heartbeat upsert
+ * keyed on the caller-supplied `sessionId`. Carries the identity spine
+ * (kind + project + participant triple). Re-calling with the same id is the
+ * heartbeat (advances participant.lastSeenAt).
+ */
+export const SHARED_SESSION_REGISTER_INPUT_SCHEMA = objectSchema({
+    sessionId: STRING_SCHEMA,
+    kind: SHARED_SESSION_KIND_SCHEMA,
+    project: STRING_SCHEMA,
+    title: STRING_SCHEMA,
+    participant: SHARED_SESSION_PARTICIPANT_SCHEMA,
+    reopen: BOOLEAN_SCHEMA,
+}, ['sessionId', 'participant'], { additionalProperties: true });
 export const SHARED_SESSION_MESSAGE_SCHEMA = objectSchema({
     id: STRING_SCHEMA,
     sessionId: STRING_SCHEMA,
@@ -65,7 +92,10 @@ export const SHARED_SESSION_MESSAGE_SCHEMA = objectSchema({
 }, ['id', 'sessionId', 'role', 'body', 'createdAt', 'metadata']);
 export const SHARED_SESSION_RECORD_SCHEMA = objectSchema({
     id: STRING_SCHEMA,
-    kind: SHARED_SESSION_KIND_SCHEMA,
+    // Open on READ: an unknown kind must not blank the record (or, per-record, the
+    // whole list). Write validation stays strict via SHARED_SESSION_REGISTER_INPUT_SCHEMA.
+    kind: SHARED_SESSION_KIND_READ_SCHEMA,
+    project: STRING_SCHEMA,
     title: STRING_SCHEMA,
     status: enumSchema(['active', 'closed']),
     createdAt: NUMBER_SCHEMA,
@@ -74,6 +104,7 @@ export const SHARED_SESSION_RECORD_SCHEMA = objectSchema({
     closedAt: NUMBER_SCHEMA,
     lastActivityAt: NUMBER_SCHEMA,
     messageCount: NUMBER_SCHEMA,
+    retainedMessageCount: NUMBER_SCHEMA,
     pendingInputCount: NUMBER_SCHEMA,
     routeIds: STRING_LIST_SCHEMA,
     surfaceKinds: STRING_LIST_SCHEMA,
@@ -192,6 +223,18 @@ export const SHARED_SESSION_WITH_INPUTS_SCHEMA = objectSchema({
 export const SHARED_SESSION_CREATE_OUTPUT_SCHEMA = objectSchema({
     session: SHARED_SESSION_RECORD_SCHEMA,
 }, ['session']);
+/**
+ * Output of sessions.register. Beyond the record it carries honest lifecycle
+ * disposition: `reopened` is true only when this call reopened a closed session,
+ * and `conflict` is present (status:'closed') when register targeted a closed
+ * session WITHOUT reopen:true — the heartbeat was recorded but the session was
+ * left closed.
+ */
+export const SHARED_SESSION_REGISTER_OUTPUT_SCHEMA = objectSchema({
+    session: SHARED_SESSION_RECORD_SCHEMA,
+    reopened: BOOLEAN_SCHEMA,
+    conflict: objectSchema({ status: enumSchema(['closed']) }, ['status']),
+}, ['session', 'reopened']);
 export const SHARED_SESSION_CONVERSATION_ROUTE_OUTPUT_SCHEMA = objectSchema({
     messageId: STRING_SCHEMA,
     routedTo: STRING_SCHEMA,
@@ -348,6 +391,17 @@ export const APPROVAL_ACTION_INPUT_SCHEMA = objectSchema({
     note: STRING_SCHEMA,
     remember: BOOLEAN_SCHEMA,
 }, ['approvalId'], { additionalProperties: false });
+// approvals.approve additionally accepts an optional per-hunk selection. Absent
+// selectedHunks = approve the whole request (exact back-compat). When present,
+// the broker filters the edit-tool `edits` array to those indices server-side
+// so TUI and webui produce identical modified-edit args; an out-of-range index
+// or a non-edit approval is a 400.
+export const APPROVAL_APPROVE_INPUT_SCHEMA = objectSchema({
+    approvalId: STRING_SCHEMA,
+    note: STRING_SCHEMA,
+    remember: BOOLEAN_SCHEMA,
+    selectedHunks: arraySchema(NUMBER_SCHEMA),
+}, ['approvalId'], { additionalProperties: false });
 export const APPROVAL_ACTION_OUTPUT_SCHEMA = objectSchema({
     approval: SHARED_APPROVAL_RECORD_SCHEMA,
 }, ['approval']);

package/dist/platform/control-plane/operator-contract-schemas.d.ts

@@ -1,5 +1,6 @@
 export * from './operator-contract-schemas-control.js';
 export * from './operator-contract-schemas-domains.js';
+export * from './operator-contract-schemas-fleet.js';
 export * from './operator-contract-schemas-permissions.js';
 export * from './operator-contract-schemas-remote.js';
 export * from './operator-contract-schemas-runtime.js';

package/dist/platform/control-plane/operator-contract-schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator-contract-schemas.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract-schemas.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"operator-contract-schemas.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract-schemas.ts"],"names":[],"mappings":"AAAA,cAAc,wCAAwC,CAAC;AACvD,cAAc,wCAAwC,CAAC;AACvD,cAAc,sCAAsC,CAAC;AACrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC;AACvD,cAAc,0CAA0C,CAAC"}

package/dist/platform/control-plane/operator-contract-schemas.js

@@ -1,5 +1,6 @@
 export * from './operator-contract-schemas-control.js';
 export * from './operator-contract-schemas-domains.js';
+export * from './operator-contract-schemas-fleet.js';
 export * from './operator-contract-schemas-permissions.js';
 export * from './operator-contract-schemas-remote.js';
 export * from './operator-contract-schemas-runtime.js';

package/dist/platform/control-plane/operator-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operator-contract.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA0B,oBAAoB,EAA2B,MAAM,qBAAqB,CAAC;AAiBjH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAYhF,YAAY,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAqBhF,eAAO,MAAM,wBAAwB,yBAsE+B,CAAC;AAoErE,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,wBAAwB,CAyB7F"}
+{"version":3,"file":"operator-contract.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/operator-contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA0B,oBAAoB,EAA2B,MAAM,qBAAqB,CAAC;AAkBjH,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAYhF,YAAY,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAqBhF,eAAO,MAAM,wBAAwB,yBA4E+B,CAAC;AAoErE,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,oBAAoB,GAAG,wBAAwB,CA0B7F"}

package/dist/platform/control-plane/operator-contract.js

@@ -1,6 +1,7 @@
 import { getOperatorContract } from '@pellux/goodvibes-contracts';
 import { BOOLEAN_SCHEMA, METHOD_DESCRIPTOR_SCHEMA, EVENT_DESCRIPTOR_SCHEMA, NUMBER_SCHEMA, STRING_SCHEMA, arraySchema, objectSchema, } from './method-catalog-shared.js';
 import { CONTROL_AUTH_CURRENT_RESPONSE_SCHEMA, CONTROL_AUTH_LOGIN_REQUEST_SCHEMA, CONTROL_AUTH_LOGIN_RESPONSE_SCHEMA, } from './operator-contract-schemas.js';
+import { summarizeInvokeValidationCoverage } from './invoke-input-validation.js';
 import { VERSION } from '../version.js';
 import { OPERATOR_SESSION_COOKIE_NAME } from '../security/http-auth.js';
 const OPERATOR_CONTRACT_VERSION = 1;
@@ -79,6 +80,12 @@ export const OPERATOR_CONTRACT_SCHEMA = objectSchema({
             withDomains: NUMBER_SCHEMA,
             withWireEvents: NUMBER_SCHEMA,
         }, ['events', 'withDomains', 'withWireEvents']),
+        validationCoverage: objectSchema({
+            methods: NUMBER_SCHEMA,
+            validated: NUMBER_SCHEMA,
+            skippedGeneric: NUMBER_SCHEMA,
+            skippedUntyped: NUMBER_SCHEMA,
+        }, ['methods', 'validated', 'skippedGeneric', 'skippedUntyped']),
     }, ['methods', 'events', 'schemaCoverage', 'eventCoverage']),
     peer: objectSchema({
         contractPath: STRING_SCHEMA,
@@ -171,6 +178,7 @@ export function buildOperatorContract(catalog) {
             events,
             schemaCoverage: summarizeSchemaCoverage(catalog.list()),
             eventCoverage: summarizeEventCoverage(catalog.listEvents()),
+            validationCoverage: summarizeInvokeValidationCoverage(catalog.list()),
         },
     };
 }

package/dist/platform/control-plane/routes/checkpoints.d.ts

@@ -0,0 +1,39 @@
+/**
+ * routes/checkpoints.ts
+ *
+ * W3-S2 — `checkpoints.list` / `checkpoints.create` / `checkpoints.diff` /
+ * `checkpoints.restore` gateway-method handlers over the ALREADY
+ * daemon-resident `WorkspaceCheckpointManager` (constructed +
+ * eagerly-`init()`'d at ../../runtime/services.ts:620, exposed on
+ * RuntimeServices at :245). Thin verb registration over an existing manager
+ * — see routes/fleet.ts's header comment for the full rationale on why these
+ * are wired via `GatewayMethodCatalog.register(descriptor, handler)` instead
+ * of a daemon-sdk REST route or a router.ts change.
+ *
+ * IMPORTANT (brief-mandated, do not "fix"): `checkpoints.restore` executes
+ * the restore immediately, with NO server-side confirmation gate. The TUI
+ * gates this behind a confirm overlay in the UI layer
+ * (src/input/commands/checkpoint-runtime.ts, DiffPanel.confirmOverlay) —
+ * confirmation is the CALLING SURFACE's responsibility, not the wire verb's.
+ * A future caller (webui) that fires this unguarded will perform a real
+ * git-backed workspace rewrite.
+ */
+import type { GatewayMethodCatalog } from '../method-catalog.js';
+import type { GatewayMethodHandler } from '../method-catalog-shared.js';
+import type { WorkspaceCheckpointManager } from '../../workspace/checkpoint/manager.js';
+/** Structural deps — the read/write surface `checkpoints.*` needs. */
+export type CheckpointsGatewayManager = Pick<WorkspaceCheckpointManager, 'list' | 'create' | 'diff' | 'restore'>;
+export declare function createCheckpointsListHandler(manager: CheckpointsGatewayManager): GatewayMethodHandler;
+export declare function createCheckpointsCreateHandler(manager: CheckpointsGatewayManager): GatewayMethodHandler;
+export declare function createCheckpointsDiffHandler(manager: CheckpointsGatewayManager): GatewayMethodHandler;
+export declare function createCheckpointsRestoreHandler(manager: CheckpointsGatewayManager): GatewayMethodHandler;
+/**
+ * Attach the `checkpoints.*` handlers to the descriptors already registered
+ * (without a handler) from ../method-catalog-control-core.ts's static
+ * builtin array. Call once, at RuntimeServices construction time, after
+ * `workspaceCheckpointManager` exists. A missing descriptor is a silent
+ * no-op — see routes/fleet.ts's `registerFleetGatewayMethods` for the same
+ * rationale.
+ */
+export declare function registerCheckpointGatewayMethods(catalog: GatewayMethodCatalog, manager: CheckpointsGatewayManager): void;
+//# sourceMappingURL=checkpoints.d.ts.map

package/dist/platform/control-plane/routes/checkpoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"checkpoints.d.ts","sourceRoot":"","sources":["../../../../src/platform/control-plane/routes/checkpoints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,uCAAuC,CAAC;AA8GxF,sEAAsE;AACtE,MAAM,MAAM,yBAAyB,GAAG,IAAI,CAAC,0BAA0B,EAAE,MAAM,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAC,CAAC;AAEjH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,yBAAyB,GAAG,oBAAoB,CASrG;AAED,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,yBAAyB,GAAG,oBAAoB,CAkBvG;AAED,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,yBAAyB,GAAG,oBAAoB,CAQrG;AAED,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,yBAAyB,GAAG,oBAAoB,CAUxG;AAED;;;;;;;GAOG;AACH,wBAAgB,gCAAgC,CAAC,OAAO,EAAE,oBAAoB,EAAE,OAAO,EAAE,yBAAyB,GAAG,IAAI,CAYxH"}

package/dist/platform/control-plane/routes/checkpoints.js

@@ -0,0 +1,166 @@
+import { GatewayVerbError } from './gateway-verb-error.js';
+import { readInvocationParams } from './invocation-params.js';
+const CHECKPOINT_KINDS = ['turn', 'agent-run', 'manual'];
+const RETENTION_CLASSES = ['short', 'standard', 'forensic'];
+const CHECKPOINTS_LIST_DEFAULT_LIMIT = 100;
+const CHECKPOINTS_LIST_MAX_LIMIT = 500;
+/**
+ * `WorkspaceCheckpointManager.requireCheckpoint` (../../workspace/checkpoint/manager.ts:599-604,
+ * private) throws a plain `Error` with this exact message shape for an
+ * unknown/gc'd id. `diff`/`restore` both route through it. There is no
+ * public `get(id)` to pre-check existence without a second full manager
+ * call, so this handler matches the message text the manager already
+ * commits to (any manager.ts rewrite of that string is covered by the
+ * bootDaemon proof test — see test/w3-s2-*.test.ts — as a regression net,
+ * not by this string match alone).
+ */
+const NO_CHECKPOINT_FOUND_MARKER = 'no checkpoint found with id';
+async function callOrHonestNotFound(fn) {
+    try {
+        return await fn();
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        if (message.includes(NO_CHECKPOINT_FOUND_MARKER)) {
+            // Preserve the manager's own message (it already names the specific
+            // missing id) — only the status/code are being upgraded from the
+            // blanket 500 a plain throw would collapse to.
+            throw new GatewayVerbError(message, 'NOT_FOUND', 404);
+        }
+        throw err;
+    }
+}
+function optionalString(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+function requiredString(value, field) {
+    if (typeof value !== 'string' || value.length === 0) {
+        throw new GatewayVerbError(`Missing required field: ${field}`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function optionalNumber(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    const n = typeof value === 'number' ? value : Number(value);
+    if (!Number.isFinite(n)) {
+        throw new GatewayVerbError(`Invalid number for field: ${field}`, 'INVALID_ARGUMENT', 400);
+    }
+    return n;
+}
+function optionalStringArray(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (!Array.isArray(value) || !value.every((v) => typeof v === 'string')) {
+        throw new GatewayVerbError('Invalid field: paths must be a string array', 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function optionalBoolean(value, field) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'boolean') {
+        throw new GatewayVerbError(`Invalid boolean for field: ${field}`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function validateCheckpointKind(value, required) {
+    if (value === undefined || value === null) {
+        if (required)
+            throw new GatewayVerbError('Missing required field: kind', 'INVALID_ARGUMENT', 400);
+        return undefined;
+    }
+    if (typeof value !== 'string' || !CHECKPOINT_KINDS.includes(value)) {
+        throw new GatewayVerbError(`Invalid kind: ${String(value)} (expected one of ${CHECKPOINT_KINDS.join(', ')})`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function validateRetentionClass(value) {
+    if (value === undefined || value === null)
+        return undefined;
+    if (typeof value !== 'string' || !RETENTION_CLASSES.includes(value)) {
+        throw new GatewayVerbError(`Invalid retentionClass: ${String(value)} (expected one of ${RETENTION_CLASSES.join(', ')})`, 'INVALID_ARGUMENT', 400);
+    }
+    return value;
+}
+function clampLimit(raw) {
+    if (raw === undefined || raw === null)
+        return CHECKPOINTS_LIST_DEFAULT_LIMIT;
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isFinite(n) || n <= 0) {
+        throw new GatewayVerbError(`Invalid limit: ${String(raw)}`, 'INVALID_ARGUMENT', 400);
+    }
+    return Math.min(Math.floor(n), CHECKPOINTS_LIST_MAX_LIMIT);
+}
+export function createCheckpointsListHandler(manager) {
+    return async (invocation) => {
+        const params = readInvocationParams(invocation);
+        const kind = validateCheckpointKind(params.kind, false);
+        const since = optionalNumber(params.since, 'since');
+        const limit = clampLimit(params.limit);
+        const checkpoints = await manager.list({ kind, since, limit });
+        return { checkpoints };
+    };
+}
+export function createCheckpointsCreateHandler(manager) {
+    return async (invocation) => {
+        const body = readInvocationParams(invocation);
+        const kind = validateCheckpointKind(body.kind, true);
+        if (!kind)
+            throw new GatewayVerbError('Missing required field: kind', 'INVALID_ARGUMENT', 400);
+        const checkpoint = await manager.create({
+            kind,
+            label: optionalString(body.label),
+            retentionClass: validateRetentionClass(body.retentionClass),
+            turnId: optionalString(body.turnId),
+            agentId: optionalString(body.agentId),
+            paths: optionalStringArray(body.paths),
+        });
+        // `create` returns null when the workspace tree is unchanged since the
+        // parent checkpoint (manager.ts:349-357) — an honest no-op, not an
+        // error and not a fabricated checkpoint record.
+        return { checkpoint, noop: checkpoint === null };
+    };
+}
+export function createCheckpointsDiffHandler(manager) {
+    return async (invocation) => {
+        const params = readInvocationParams(invocation);
+        const a = requiredString(params.a, 'a');
+        const b = optionalString(params.b);
+        const diff = await callOrHonestNotFound(() => manager.diff(a, b));
+        return { diff };
+    };
+}
+export function createCheckpointsRestoreHandler(manager) {
+    return async (invocation) => {
+        const body = readInvocationParams(invocation);
+        const id = requiredString(body.id, 'id');
+        const result = await callOrHonestNotFound(() => manager.restore(id, {
+            paths: optionalStringArray(body.paths),
+            safetyCheckpoint: optionalBoolean(body.safetyCheckpoint, 'safetyCheckpoint'),
+        }));
+        return { result };
+    };
+}
+/**
+ * Attach the `checkpoints.*` handlers to the descriptors already registered
+ * (without a handler) from ../method-catalog-control-core.ts's static
+ * builtin array. Call once, at RuntimeServices construction time, after
+ * `workspaceCheckpointManager` exists. A missing descriptor is a silent
+ * no-op — see routes/fleet.ts's `registerFleetGatewayMethods` for the same
+ * rationale.
+ */
+export function registerCheckpointGatewayMethods(catalog, manager) {
+    const listDescriptor = catalog.get('checkpoints.list');
+    if (listDescriptor)
+        catalog.register(listDescriptor, createCheckpointsListHandler(manager), { replace: true });
+    const createDescriptor = catalog.get('checkpoints.create');
+    if (createDescriptor)
+        catalog.register(createDescriptor, createCheckpointsCreateHandler(manager), { replace: true });
+    const diffDescriptor = catalog.get('checkpoints.diff');
+    if (diffDescriptor)
+        catalog.register(diffDescriptor, createCheckpointsDiffHandler(manager), { replace: true });
+    const restoreDescriptor = catalog.get('checkpoints.restore');
+    if (restoreDescriptor)
+        catalog.register(restoreDescriptor, createCheckpointsRestoreHandler(manager), { replace: true });
+}