@pellux/goodvibes-sdk 0.38.0 → 1.1.0

package/dist/platform/control-plane/method-catalog-calendar.d.ts

@@ -4,6 +4,22 @@ import type { GatewayMethodDescriptor } from './method-catalog-shared.js';
  * import/export through the standard operator method protocol. Daemon-backed;
  * the SDK publishes the typed contract surface (no internal handler). Local .ics
  * parsing is handled agent-side and does not depend on these contracts.
+ *
+ * Route-reconcile debt (surfaced by a route-advertisement audit, retired here): none of these five
+ * http paths are served by the daemon router — there is no /api/calendar
+ * surface at any prefix (confirmed by reading router.ts, every dispatch
+ * chain it delegates to, and grepping the full path across packages/sdk/src
+ * and packages/daemon-sdk/src; there is no calendar-routes.ts and no
+ * calendar handler anywhere). These were originally grandfathered into
+ * KNOWN_PRE_EXISTING_ROUTE_DEBT in test/w4-a3-capability-route-reconcile.test.ts
+ * as an out-of-ownership finding that audit incidentally surfaced; marked
+ * `invokable: false` here so the published contract and the live
+ * method-dispatch path both say "cataloged, not callable" instead of
+ * letting a caller discover the 404 the hard way. Un-mark a method once its
+ * real CalDAV-backed route or handler exists — the route-reconcile
+ * regression gate (method-catalog-route-reconcile.ts, exercised in
+ * test/w4-a3-capability-route-reconcile.test.ts) will catch it if this
+ * comment goes stale and a route reappears without the flag being cleared.
  */
 export declare const builtinGatewayCalendarMethodDescriptors: readonly GatewayMethodDescriptor[];
 //# sourceMappingURL=method-catalog-calendar.d.ts.map

package/dist/platform/control-plane/method-catalog-calendar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method-catalog-calendar.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-calendar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAiC1E;;;;;GAKG;AACH,eAAO,MAAM,uCAAuC,EAAE,SAAS,uBAAuB,EAyFrF,CAAC"}
+{"version":3,"file":"method-catalog-calendar.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-calendar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAiC1E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,uCAAuC,EAAE,SAAS,uBAAuB,EA8FrF,CAAC"}

package/dist/platform/control-plane/method-catalog-calendar.js

@@ -24,6 +24,22 @@ const CALENDAR_EVENT_DETAIL_SCHEMA = objectSchema({
  * import/export through the standard operator method protocol. Daemon-backed;
  * the SDK publishes the typed contract surface (no internal handler). Local .ics
  * parsing is handled agent-side and does not depend on these contracts.
+ *
+ * Route-reconcile debt (surfaced by a route-advertisement audit, retired here): none of these five
+ * http paths are served by the daemon router — there is no /api/calendar
+ * surface at any prefix (confirmed by reading router.ts, every dispatch
+ * chain it delegates to, and grepping the full path across packages/sdk/src
+ * and packages/daemon-sdk/src; there is no calendar-routes.ts and no
+ * calendar handler anywhere). These were originally grandfathered into
+ * KNOWN_PRE_EXISTING_ROUTE_DEBT in test/w4-a3-capability-route-reconcile.test.ts
+ * as an out-of-ownership finding that audit incidentally surfaced; marked
+ * `invokable: false` here so the published contract and the live
+ * method-dispatch path both say "cataloged, not callable" instead of
+ * letting a caller discover the 404 the hard way. Un-mark a method once its
+ * real CalDAV-backed route or handler exists — the route-reconcile
+ * regression gate (method-catalog-route-reconcile.ts, exercised in
+ * test/w4-a3-capability-route-reconcile.test.ts) will catch it if this
+ * comment goes stale and a route reappears without the flag being cleared.
  */
 export const builtinGatewayCalendarMethodDescriptors = [
     methodDescriptor({
@@ -40,6 +56,7 @@ export const builtinGatewayCalendarMethodDescriptors = [
             limit: NUMBER_SCHEMA,
         }),
         outputSchema: listOutputSchema('events', CALENDAR_EVENT_SUMMARY_SCHEMA),
+        invokable: false,
     }),
     methodDescriptor({
         id: 'calendar.events.get',
@@ -53,6 +70,7 @@ export const builtinGatewayCalendarMethodDescriptors = [
             calendarId: STRING_SCHEMA,
         }, ['eventId']),
         outputSchema: CALENDAR_EVENT_DETAIL_SCHEMA,
+        invokable: false,
     }),
     methodDescriptor({
         id: 'calendar.events.create',
@@ -77,6 +95,7 @@ export const builtinGatewayCalendarMethodDescriptors = [
             uid: STRING_SCHEMA,
             createdAt: STRING_SCHEMA,
         }, ['eventId', 'uid', 'createdAt']),
+        invokable: false,
     }),
     methodDescriptor({
         id: 'calendar.ics.import',
@@ -96,6 +115,7 @@ export const builtinGatewayCalendarMethodDescriptors = [
             eventIds: arraySchema(STRING_SCHEMA),
             errors: arraySchema(STRING_SCHEMA),
         }, ['imported', 'eventIds', 'errors']),
+        invokable: false,
     }),
     methodDescriptor({
         id: 'calendar.ics.export',
@@ -113,5 +133,6 @@ export const builtinGatewayCalendarMethodDescriptors = [
             icsContent: STRING_SCHEMA,
             eventCount: NUMBER_SCHEMA,
         }, ['icsContent', 'eventCount']),
+        invokable: false,
     }),
 ];

package/dist/platform/control-plane/method-catalog-channels.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method-catalog-channels.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-channels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAuF1E,eAAO,MAAM,sCAAsC,EAAE,SAAS,uBAAuB,EAoqBpF,CAAC"}
+{"version":3,"file":"method-catalog-channels.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-channels.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAuF1E,eAAO,MAAM,sCAAsC,EAAE,SAAS,uBAAuB,EAisBpF,CAAC"}

package/dist/platform/control-plane/method-catalog-channels.js

@@ -442,9 +442,9 @@ export const builtinGatewayChannelMethodDescriptors = [
         outputSchema: WATCHER_RECORD_SCHEMA,
     }),
     methodDescriptor({
-        id: 'watchers.patch',
-        title: 'Patch Watcher',
-        description: 'Patch an existing watcher.',
+        id: 'watchers.update',
+        title: 'Update Watcher',
+        description: 'Update an existing watcher. (Renamed from watchers.patch in the 1.0.0 core-verb rename — canonical verb is update, not patch.)',
         category: 'watchers',
         scopes: ['write:watchers'],
         access: 'admin',
@@ -584,6 +584,27 @@ export const builtinGatewayChannelMethodDescriptors = [
         outputSchema: SERVICE_STATUS_SCHEMA,
         dangerous: true,
     }),
+    /**
+     * Route-reconcile debt (surfaced by an audit finding, retired here): the eight
+     * channels.inbox.* / channels.routing.* / channels.drafts.* methods below
+     * advertise http paths with no dispatch route anywhere — confirmed by
+     * reading router.ts, every dispatch chain it delegates to (operator.ts in
+     * particular, which is where every other channels.* path is matched), and
+     * grepping the full path across packages/sdk/src and
+     * packages/daemon-sdk/src: channel-routes.ts defines no inbox/routing/
+     * drafts handler at all, so there is nothing for a route to call even in
+     * principle. These were originally grandfathered into
+     * KNOWN_PRE_EXISTING_ROUTE_DEBT in test/w4-a3-capability-route-reconcile.test.ts
+     * as an out-of-ownership finding the audit incidentally surfaced; marked
+     * `invokable: false` here so the published contract and the live
+     * method-dispatch path both say "cataloged, not callable" instead of
+     * letting a caller discover the 404 the hard way. Un-mark a method once
+     * its real route or handler exists — the route-reconcile regression gate
+     * (method-catalog-route-reconcile.ts, exercised in
+     * test/w4-a3-capability-route-reconcile.test.ts) will catch it if this
+     * comment goes stale and a route reappears without the flag being
+     * cleared.
+     */
     methodDescriptor({
         id: 'channels.inbox.list',
         title: 'List Channel Inbox',
@@ -602,6 +623,7 @@ export const builtinGatewayChannelMethodDescriptors = [
             truncated: BOOLEAN_SCHEMA,
             cursor: STRING_SCHEMA,
         }, ['items', 'total', 'truncated']),
+        invokable: false,
     }),
     methodDescriptor({
         id: 'channels.routing.list',
@@ -619,6 +641,7 @@ export const builtinGatewayChannelMethodDescriptors = [
             routes: arraySchema(CHANNEL_ROUTING_RULE_SCHEMA),
             total: NUMBER_SCHEMA,
         }, ['routes', 'total']),
+        invokable: false,
     }),
     methodDescriptor({
         id: 'channels.routing.assign',
@@ -646,6 +669,7 @@ export const builtinGatewayChannelMethodDescriptors = [
             updatedAt: STRING_SCHEMA,
         }, ['assignmentId', 'surfaceKind', 'profileId', 'createdAt', 'updatedAt']),
         dangerous: true,
+        invokable: false,
     }),
     methodDescriptor({
         id: 'channels.routing.delete',
@@ -661,6 +685,7 @@ export const builtinGatewayChannelMethodDescriptors = [
             assignmentId: STRING_SCHEMA,
         }, ['deleted', 'assignmentId']),
         dangerous: true,
+        invokable: false,
     }),
     methodDescriptor({
         id: 'channels.drafts.list',
@@ -677,6 +702,7 @@ export const builtinGatewayChannelMethodDescriptors = [
             drafts: arraySchema(CHANNEL_DRAFT_SCHEMA),
             total: NUMBER_SCHEMA,
         }, ['drafts', 'total']),
+        invokable: false,
     }),
     methodDescriptor({
         id: 'channels.drafts.get',
@@ -687,6 +713,7 @@ export const builtinGatewayChannelMethodDescriptors = [
         http: { method: 'GET', path: '/api/channels/drafts/{draftId}' },
         inputSchema: objectSchema({ draftId: STRING_SCHEMA }, ['draftId']),
         outputSchema: CHANNEL_DRAFT_GET_OUTPUT_SCHEMA,
+        invokable: false,
     }),
     methodDescriptor({
         id: 'channels.drafts.save',
@@ -702,6 +729,7 @@ export const builtinGatewayChannelMethodDescriptors = [
             created: BOOLEAN_SCHEMA,
         }, ['draft', 'created']),
         dangerous: true,
+        invokable: false,
     }),
     methodDescriptor({
         id: 'channels.drafts.delete',
@@ -717,5 +745,6 @@ export const builtinGatewayChannelMethodDescriptors = [
             draftId: STRING_SCHEMA,
         }, ['deleted', 'draftId']),
         dangerous: true,
+        invokable: false,
     }),
 ];

package/dist/platform/control-plane/method-catalog-control-automation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method-catalog-control-automation.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-control-automation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAsC1E,eAAO,MAAM,gDAAgD,EAAE,SAAS,uBAAuB,EA0b9F,CAAC"}
+{"version":3,"file":"method-catalog-control-automation.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-control-automation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAsC1E,eAAO,MAAM,gDAAgD,EAAE,SAAS,uBAAuB,EA2a9F,CAAC"}

package/dist/platform/control-plane/method-catalog-control-automation.js

@@ -69,9 +69,9 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         outputSchema: AUTOMATION_JOB_SCHEMA,
     }),
     methodDescriptor({
-        id: 'automation.jobs.patch',
-        title: 'Patch Automation Job',
-        description: 'Patch a durable automation job.',
+        id: 'automation.jobs.update',
+        title: 'Update Automation Job',
+        description: 'Update a durable automation job. (Renamed from automation.jobs.patch in the 1.0.0 core-verb rename — canonical verb is update, not patch.)',
         category: 'automation',
         scopes: ['write:automation'],
         http: { method: 'PATCH', path: '/api/automation/jobs/{jobId}' },
@@ -139,28 +139,13 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         inputSchema: objectSchema({ jobId: STRING_SCHEMA }, ['jobId']),
         outputSchema: objectSchema({ id: STRING_SCHEMA, enabled: BOOLEAN_SCHEMA }, ['id', 'enabled'], { additionalProperties: true }),
     }),
-    methodDescriptor({
-        id: 'automation.jobs.pause',
-        title: 'Pause Automation Job',
-        description: 'Pause a durable automation job.',
-        category: 'automation',
-        scopes: ['write:automation'],
-        http: { method: 'POST', path: '/api/automation/jobs/{jobId}/pause' },
-        events: [runtimeEventId('automation')],
-        inputSchema: objectSchema({ jobId: STRING_SCHEMA }, ['jobId']),
-        outputSchema: objectSchema({ id: STRING_SCHEMA, enabled: BOOLEAN_SCHEMA }, ['id', 'enabled'], { additionalProperties: true }),
-    }),
-    methodDescriptor({
-        id: 'automation.jobs.resume',
-        title: 'Resume Automation Job',
-        description: 'Resume a durable automation job.',
-        category: 'automation',
-        scopes: ['write:automation'],
-        http: { method: 'POST', path: '/api/automation/jobs/{jobId}/resume' },
-        events: [runtimeEventId('automation')],
-        inputSchema: objectSchema({ jobId: STRING_SCHEMA }, ['jobId']),
-        outputSchema: objectSchema({ id: STRING_SCHEMA, enabled: BOOLEAN_SCHEMA }, ['id', 'enabled'], { additionalProperties: true }),
-    }),
+    // automation.jobs.pause / automation.jobs.resume were RETIRED in the 1.0.0
+    // core-verb rename (see CHANGELOG 1.0.0): they were a byte-identical redundant lifecycle
+    // pair with automation.jobs.disable/enable (same {id,enabled} output shape,
+    // same semantics — pause==disable, resume==enable). The canonical verbs are
+    // enable/disable; consumers that exposed a "pause"/"resume" user-facing verb
+    // now map it onto automation.jobs.disable/automation.jobs.enable. See
+    // packages/contracts/src/core-verbs.ts and docs/decisions/2026-07-06-core-verb-spec.md.
     methodDescriptor({
         id: 'automation.jobs.run',
         title: 'Run Automation Job Now',
@@ -258,7 +243,7 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         outputSchema: DELIVERY_OUTPUT_SCHEMA,
     }),
     methodDescriptor({
-        id: 'schedules.list',
+        id: 'automation.schedules.list',
         title: 'List Schedules',
         description: 'Return schedule records.',
         category: 'automation',
@@ -268,7 +253,7 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         outputSchema: AUTOMATION_SCHEDULES_OUTPUT_SCHEMA,
     }),
     methodDescriptor({
-        id: 'schedules.create',
+        id: 'automation.schedules.create',
         title: 'Create Schedule',
         description: 'Create a schedule record.',
         category: 'automation',
@@ -305,7 +290,7 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         outputSchema: AUTOMATION_JOB_SCHEMA,
     }),
     methodDescriptor({
-        id: 'schedules.delete',
+        id: 'automation.schedules.delete',
         title: 'Delete Schedule',
         description: 'Delete a schedule record.',
         category: 'automation',
@@ -316,7 +301,7 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         dangerous: true,
     }),
     methodDescriptor({
-        id: 'schedules.enable',
+        id: 'automation.schedules.enable',
         title: 'Enable Schedule',
         description: 'Enable a schedule record.',
         category: 'automation',
@@ -326,7 +311,7 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         outputSchema: objectSchema({ id: STRING_SCHEMA, enabled: BOOLEAN_SCHEMA }, ['id', 'enabled'], { additionalProperties: true }),
     }),
     methodDescriptor({
-        id: 'schedules.disable',
+        id: 'automation.schedules.disable',
         title: 'Disable Schedule',
         description: 'Disable a schedule record.',
         category: 'automation',
@@ -336,7 +321,7 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         outputSchema: objectSchema({ id: STRING_SCHEMA, enabled: BOOLEAN_SCHEMA }, ['id', 'enabled'], { additionalProperties: true }),
     }),
     methodDescriptor({
-        id: 'schedules.run',
+        id: 'automation.schedules.run',
         title: 'Run Schedule Now',
         description: 'Trigger a schedule immediately.',
         category: 'automation',
@@ -407,9 +392,9 @@ export const builtinGatewayControlAutomationMethodDescriptors = [
         outputSchema: ROUTE_BINDING_SCHEMA,
     }),
     methodDescriptor({
-        id: 'routes.bindings.patch',
-        title: 'Patch Route Binding',
-        description: 'Patch an existing route binding.',
+        id: 'routes.bindings.update',
+        title: 'Update Route Binding',
+        description: 'Update an existing route binding. (Renamed from routes.bindings.patch in the 1.0.0 core-verb rename — canonical verb is update, not patch.)',
         category: 'routes',
         scopes: ['write:routes'],
         access: 'admin',

package/dist/platform/control-plane/method-catalog-control-companion.d.ts

@@ -0,0 +1,15 @@
+/**
+ * method-catalog-control-companion.ts
+ *
+ * Companion-chat method catalog registration, split out of
+ * method-catalog-control-core.ts (see CHANGELOG 1.0.0) to stay under the repo's 800-line
+ * hand-authored file cap (see scripts/check-line-cap.ts) — this block is
+ * self-contained (companion.chat.* descriptors only) and control.ts folds it
+ * in unchanged, so this is a pure file-organization move with no API surface
+ * change beyond the delete-honesty split it carries (companion.chat.sessions.close
+ * as a distinct soft-close verb alongside a genuinely hard-deleting
+ * companion.chat.sessions.delete).
+ */
+import type { GatewayMethodDescriptor } from './method-catalog-shared.js';
+export declare const builtinGatewayControlCompanionMethodDescriptors: readonly GatewayMethodDescriptor[];
+//# sourceMappingURL=method-catalog-control-companion.d.ts.map

package/dist/platform/control-plane/method-catalog-control-companion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"method-catalog-control-companion.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-control-companion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAkB1E,eAAO,MAAM,+CAA+C,EAAE,SAAS,uBAAuB,EA6K7F,CAAC"}

package/dist/platform/control-plane/method-catalog-control-companion.js

@@ -0,0 +1,176 @@
+import { BOOLEAN_SCHEMA, EMPTY_OBJECT_SCHEMA, NUMBER_SCHEMA, STRING_SCHEMA, arraySchema, bodyEnvelopeSchema, methodDescriptor, objectSchema, } from './method-catalog-shared.js';
+import { COMPANION_CHAT_MESSAGES_LIST_SCHEMA, COMPANION_CHAT_SESSION_SCHEMA, COMPANION_CHAT_SESSIONS_LIST_SCHEMA, COMPANION_CHAT_SESSION_WITH_MESSAGES_SCHEMA, } from './operator-contract-schemas.js';
+export const builtinGatewayControlCompanionMethodDescriptors = [
+    methodDescriptor({
+        id: 'companion.chat.sessions.create',
+        title: 'Create Companion Chat Session',
+        description: 'Create a new companion-chat session. Optional `provider` / `model` override the registry default; `title` and `systemPrompt` are stored on the session record.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'POST', path: '/api/companion/chat/sessions' },
+        inputSchema: bodyEnvelopeSchema({
+            title: STRING_SCHEMA,
+            model: STRING_SCHEMA,
+            provider: STRING_SCHEMA,
+            systemPrompt: STRING_SCHEMA,
+        }, []),
+        outputSchema: objectSchema({
+            sessionId: STRING_SCHEMA,
+            createdAt: NUMBER_SCHEMA,
+            session: COMPANION_CHAT_SESSION_SCHEMA,
+        }, ['sessionId', 'createdAt', 'session']),
+    }),
+    methodDescriptor({
+        id: 'companion.chat.sessions.list',
+        title: 'List Companion Chat Sessions',
+        description: 'List active companion-chat sessions. Pass `includeClosed` to include recently closed sessions.',
+        category: 'companion',
+        scopes: ['read:sessions'],
+        http: { method: 'GET', path: '/api/companion/chat/sessions' },
+        inputSchema: objectSchema({
+            includeClosed: BOOLEAN_SCHEMA,
+            limit: NUMBER_SCHEMA,
+        }, []),
+        outputSchema: COMPANION_CHAT_SESSIONS_LIST_SCHEMA,
+    }),
+    methodDescriptor({
+        id: 'companion.chat.sessions.get',
+        title: 'Get Companion Chat Session',
+        description: 'Return a companion-chat session record together with its full message history.',
+        category: 'companion',
+        scopes: ['read:sessions'],
+        http: { method: 'GET', path: '/api/companion/chat/sessions/{sessionId}' },
+        inputSchema: objectSchema({ sessionId: STRING_SCHEMA }, ['sessionId']),
+        outputSchema: COMPANION_CHAT_SESSION_WITH_MESSAGES_SCHEMA,
+    }),
+    methodDescriptor({
+        id: 'companion.chat.sessions.update',
+        title: 'Update Companion Chat Session',
+        description: 'Update companion-chat session metadata, including session-local `provider` and `model`, without changing the daemon/TUI current model.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'PATCH', path: '/api/companion/chat/sessions/{sessionId}' },
+        inputSchema: bodyEnvelopeSchema({
+            title: STRING_SCHEMA,
+            model: STRING_SCHEMA,
+            provider: STRING_SCHEMA,
+            systemPrompt: STRING_SCHEMA,
+        }, []),
+        outputSchema: objectSchema({
+            session: COMPANION_CHAT_SESSION_SCHEMA,
+        }, ['session']),
+    }),
+    methodDescriptor({
+        id: 'companion.chat.sessions.close',
+        title: 'Close Companion Chat Session',
+        description: 'Close a companion-chat session (soft close). The session record and its messages are preserved in closed state and remain listable with includeClosed. Distinct from companion.chat.sessions.delete, which permanently removes the record.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'POST', path: '/api/companion/chat/sessions/{sessionId}/close' },
+        inputSchema: objectSchema({ sessionId: STRING_SCHEMA }, ['sessionId']),
+        outputSchema: objectSchema({
+            sessionId: STRING_SCHEMA,
+            status: STRING_SCHEMA,
+        }, ['sessionId', 'status']),
+    }),
+    methodDescriptor({
+        id: 'companion.chat.sessions.delete',
+        title: 'Delete Companion Chat Session',
+        description: 'Permanently remove a companion-chat session: the on-disk record file is deleted and the session is dropped from the shared session store — this does NOT merely close it (use companion.chat.sessions.close for a soft close). Requires the session to already be closed: deleting a still-active session is rejected with 409 SESSION_ACTIVE (close it, then delete). An unknown or already-deleted id is a 404 SESSION_NOT_FOUND, never a 200-noop.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'DELETE', path: '/api/companion/chat/sessions/{sessionId}' },
+        inputSchema: objectSchema({ sessionId: STRING_SCHEMA }, ['sessionId']),
+        outputSchema: objectSchema({
+            sessionId: STRING_SCHEMA,
+            deleted: BOOLEAN_SCHEMA,
+        }, ['sessionId', 'deleted']),
+    }),
+    methodDescriptor({
+        id: 'companion.chat.messages.create',
+        title: 'Send Companion Chat Message',
+        description: 'Post a user message to a companion-chat session. Accepts either `body` or `content` in the payload; `body` wins when both are provided. Attachments reference artifacts created through `artifacts.create`.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'POST', path: '/api/companion/chat/sessions/{sessionId}/messages' },
+        inputSchema: bodyEnvelopeSchema({
+            body: STRING_SCHEMA,
+            content: STRING_SCHEMA,
+            attachments: arraySchema(objectSchema({
+                artifactId: STRING_SCHEMA,
+                label: STRING_SCHEMA,
+                metadata: objectSchema({}, []),
+            }, ['artifactId'])),
+            metadata: objectSchema({}, []),
+        }, []),
+        outputSchema: objectSchema({
+            messageId: STRING_SCHEMA,
+        }, ['messageId']),
+    }),
+    methodDescriptor({
+        id: 'companion.chat.messages.list',
+        title: 'List Companion Chat Messages',
+        description: 'Return the message list for a companion-chat session.',
+        category: 'companion',
+        scopes: ['read:sessions'],
+        http: { method: 'GET', path: '/api/companion/chat/sessions/{sessionId}/messages' },
+        inputSchema: objectSchema({ sessionId: STRING_SCHEMA }, ['sessionId']),
+        outputSchema: COMPANION_CHAT_MESSAGES_LIST_SCHEMA,
+    }),
+    methodDescriptor({
+        id: 'companion.chat.messages.retry',
+        title: 'Regenerate Companion Chat Response',
+        description: 'Regenerate an assistant response. Optional `messageId` targets a specific assistant message; omitted, the latest assistant response is re-run. The prior response (and any turns after it) is SUPERSEDED — kept in the message list and on disk, flagged as retained history — never deleted, then a fresh turn re-runs from the preceding user message. Returns the superseded message ids so the caller can render the honest lineage. Rejected on a closed session (409 SESSION_CLOSED) or unknown session (404 SESSION_NOT_FOUND), and with an honest machine code (409 NO_ASSISTANT_MESSAGE) when there is nothing to regenerate.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'POST', path: '/api/companion/chat/sessions/{sessionId}/messages/retry' },
+        inputSchema: bodyEnvelopeSchema({
+            messageId: STRING_SCHEMA,
+        }, []),
+        outputSchema: objectSchema({
+            sessionId: STRING_SCHEMA,
+            regeneratedFrom: STRING_SCHEMA,
+            supersededMessageIds: arraySchema(STRING_SCHEMA),
+            turnStarted: BOOLEAN_SCHEMA,
+        }, ['sessionId', 'regeneratedFrom', 'supersededMessageIds', 'turnStarted']),
+    }),
+    methodDescriptor({
+        id: 'companion.chat.messages.edit',
+        title: 'Edit Companion Chat Message And Branch',
+        description: 'Edit a user message and branch the conversation from it. `messageId` (required) is the user message to edit; the edited text is passed as `body` or `content` (as message create accepts), with optional `attachments` referencing artifacts. The original message and everything after it are SUPERSEDED — retained as history, never deleted — a new user message carrying `revisionOf` back to the original is appended, and a fresh turn answers it. Returns the new message id and the superseded ids for honest lineage. Same closed/unknown-session refusals as companion.chat.messages.retry.',
+        category: 'companion',
+        scopes: ['write:sessions'],
+        http: { method: 'POST', path: '/api/companion/chat/sessions/{sessionId}/messages/edit' },
+        inputSchema: bodyEnvelopeSchema({
+            messageId: STRING_SCHEMA,
+            body: STRING_SCHEMA,
+            content: STRING_SCHEMA,
+            attachments: arraySchema(objectSchema({
+                artifactId: STRING_SCHEMA,
+                label: STRING_SCHEMA,
+                metadata: objectSchema({}, []),
+            }, ['artifactId'])),
+            metadata: objectSchema({}, []),
+        }, []),
+        outputSchema: objectSchema({
+            sessionId: STRING_SCHEMA,
+            editedFrom: STRING_SCHEMA,
+            messageId: STRING_SCHEMA,
+            supersededMessageIds: arraySchema(STRING_SCHEMA),
+            turnStarted: BOOLEAN_SCHEMA,
+        }, ['sessionId', 'editedFrom', 'messageId', 'supersededMessageIds', 'turnStarted']),
+    }),
+    methodDescriptor({
+        id: 'companion.chat.events.stream',
+        title: 'Stream Companion Chat Events',
+        description: 'Server-Sent Events stream of turn and agent events scoped to a single companion-chat session.',
+        category: 'companion',
+        scopes: ['read:sessions'],
+        transport: ['http'],
+        http: { method: 'GET', path: '/api/companion/chat/sessions/{sessionId}/events' },
+        inputSchema: objectSchema({ sessionId: STRING_SCHEMA }, ['sessionId']),
+        outputSchema: EMPTY_OBJECT_SCHEMA,
+        invokable: false,
+        metadata: { responseKind: 'sse', stream: true, wireEventPrefix: 'companion-chat.' },
+    }),
+];

package/dist/platform/control-plane/method-catalog-control-core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"method-catalog-control-core.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-control-core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AA4D1E,eAAO,MAAM,0CAA0C,EAAE,SAAS,uBAAuB,EAunBxF,CAAC"}
+{"version":3,"file":"method-catalog-control-core.d.ts","sourceRoot":"","sources":["../../../src/platform/control-plane/method-catalog-control-core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AA4D1E,eAAO,MAAM,0CAA0C,EAAE,SAAS,uBAAuB,EAqmBxF,CAAC"}