@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/agent/memory-prompt.ts

@@ -1,11 +1,22 @@
-import type { MemoryRecord, MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
-const DEFAULT_LIMIT = 10;
-export const MIN_PROMPT_MEMORY_CONFIDENCE = 70;
+import type { MemoryRecord, MemoryRegistry, MemoryVectorStats } from '@pellux/goodvibes-sdk/platform/state';
+// W6-C2 (E6): the recall-honesty floor + eligibility receipt now live in the SDK as
+// the ONE cross-surface contract (memory-recall-contract.ts) instead of being defined
+// per surface. This file re-exports them unchanged so every existing agent consumer
+// keeps importing from './memory-prompt.ts', while the SDK is the single source of the
+// floor (60, the store's own baseline), the flagged-record exclusion, and the honest
+// degraded-state distinction. The per-turn ranking below stays agent-local — it is
+// injection wiring on top of the contract, not the contract itself.
+import {
+  MIN_PROMPT_MEMORY_CONFIDENCE,
+  describeMemoryPromptEligibility,
+  isPromptActiveMemory,
+} from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryPromptEligibility } from '@pellux/goodvibes-sdk/platform/state';
 
-export function isPromptActiveMemory(record: MemoryRecord): boolean {
-  // Fully autonomous learning: reviewState gate removed — confidence alone qualifies a memory for prompt recall.
-  return record.confidence >= MIN_PROMPT_MEMORY_CONFIDENCE;
-}
+export { MIN_PROMPT_MEMORY_CONFIDENCE, describeMemoryPromptEligibility, isPromptActiveMemory };
+export type { MemoryPromptEligibility };
+
+const DEFAULT_LIMIT = 10;
 
 function sortMemoryForPrompt(left: MemoryRecord, right: MemoryRecord): number {
   if (right.confidence !== left.confidence) return right.confidence - left.confidence;
@@ -20,11 +31,131 @@ function formatMemoryLine(record: MemoryRecord): string {
   return `- [${record.scope}/${record.cls} ${record.confidence}%${tags}${provenance}] ${record.summary}`;
 }
 
-export function buildReviewedMemoryPrompt(memoryRegistry: MemoryRegistry, limit = DEFAULT_LIMIT): string | null {
-  const records = memoryRegistry.getAll()
-    .filter(isPromptActiveMemory)
-    .sort(sortMemoryForPrompt)
-    .slice(0, Math.max(0, limit));
+/**
+ * Per-turn semantic ranking of an already-eligible memory set (Wave-4 W4-A1B).
+ *
+ * W4-A1 shipped eligibility (confidence + reviewState + provenance) as the hard trust
+ * gate but had no per-turn query to rank WITHIN that eligible set — records were only
+ * ever ordered by stored confidence/recency, regardless of whether they had anything to
+ * do with what the user actually just asked. `rankMemoryForTurn` never touches the gate
+ * itself: it only reorders the records that already cleared describeMemoryPromptEligibility,
+ * so a budget-limited cut (the top-N prompt slice) drops the least relevant record to
+ * THIS turn instead of an arbitrary one.
+ *
+ * Degrades honestly and says why whenever it can't score: no turn text supplied, the
+ * semantic index disabled/unavailable/empty, or a real query that the index has zero
+ * vector matches for. In every degraded case the eligible set still gets the prior
+ * confidence/recency order — never silently dropped, never silently reordered on data
+ * that isn't there.
+ */
+export interface MemoryTurnRankingResult {
+  /** The eligible records, ranked — by relevance when `scored` is true, else by the prior confidence/recency order. */
+  readonly records: readonly MemoryRecord[];
+  /** Relevance percent (0-100) per record id. Only populated when `scored` is true. */
+  readonly relevanceById: ReadonlyMap<string, number>;
+  /** True when semantic relevance to the current turn actually drove the ranking above. */
+  readonly scored: boolean;
+  /** Honest reason for the degrade when `scored` is false; null when scoring succeeded or there was nothing to rank. */
+  readonly degradedReason: string | null;
+}
+
+function describeTurnRelevanceIndexUnavailable(stats: MemoryVectorStats): string | null {
+  if (!stats.enabled) return 'the semantic memory index is disabled for this store';
+  if (!stats.available) return `the semantic memory index is unavailable${stats.error ? `: ${stats.error}` : ''}`;
+  if (stats.indexedRecords === 0) return 'the semantic memory index has no indexed records yet';
+  return null;
+}
+
+/**
+ * Qualitative band for a 0-100 relevance-to-turn percent (F7a).
+ *
+ * A raw cosine-similarity percent like "28%" reads as misleadingly low out of
+ * context — it can still be the single best match among the eligible set, or
+ * a genuinely useful match on an absolute basis, but a bare number invites
+ * "only 28%? that's barely relevant." Choice made here: add a qualitative
+ * band NEXT TO the raw percent rather than normalizing against the turn's
+ * top score. Normalizing would make every record but the single best one
+ * read as comparatively weak even when several are strong matches in
+ * absolute terms, and would make a genuinely weak top match look like a
+ * confident 100%. A fixed absolute band keeps the number honest while
+ * making it readable at a glance.
+ */
+export function relevanceBand(percent: number): 'high match' | 'moderate match' | 'low match' {
+  if (percent >= 60) return 'high match';
+  if (percent >= 35) return 'moderate match';
+  return 'low match';
+}
+
+export function rankMemoryForTurn(
+  memoryRegistry: MemoryRegistry,
+  eligible: readonly MemoryRecord[],
+  turnText: string | null | undefined,
+): MemoryTurnRankingResult {
+  const fallbackOrder = (): readonly MemoryRecord[] => [...eligible].sort(sortMemoryForPrompt);
+  if (eligible.length === 0) {
+    return { records: [], relevanceById: new Map(), scored: false, degradedReason: null };
+  }
+  const trimmedTurnText = turnText?.trim() ?? '';
+  if (!trimmedTurnText) {
+    return {
+      records: fallbackOrder(),
+      relevanceById: new Map(),
+      scored: false,
+      degradedReason: 'no current-turn text available for this composition — using stored confidence/recency order',
+    };
+  }
+  const stats = memoryRegistry.vectorStats();
+  const indexUnavailable = describeTurnRelevanceIndexUnavailable(stats);
+  if (indexUnavailable) {
+    return {
+      records: fallbackOrder(),
+      relevanceById: new Map(),
+      scored: false,
+      degradedReason: `semantic index unavailable (${indexUnavailable}) — using stored confidence/recency order`,
+    };
+  }
+  // Request enough candidates back that every eligible record has a real chance to
+  // appear with its similarity score (searchSemantic slices its return to this limit
+  // after scoring, not before) — the SDK's vector store caps the underlying KNN search
+  // at 500 candidates regardless, so there is no point asking for more than that.
+  const requestLimit = Math.min(500, Math.max(eligible.length, 50));
+  const results = memoryRegistry.searchSemantic({ query: trimmedTurnText, limit: requestLimit });
+  const consultedSemanticIndex = results.some((entry) => entry.similarity > 0);
+  if (!consultedSemanticIndex) {
+    return {
+      records: fallbackOrder(),
+      relevanceById: new Map(),
+      scored: false,
+      degradedReason: "no semantic match for this turn's text — using stored confidence/recency order",
+    };
+  }
+  const eligibleIds = new Set(eligible.map((record) => record.id));
+  const relevanceById = new Map<string, number>();
+  for (const entry of results) {
+    if (!eligibleIds.has(entry.record.id)) continue;
+    relevanceById.set(entry.record.id, Math.round(Math.max(0, Math.min(1, entry.similarity)) * 100));
+  }
+  const ranked = [...eligible].sort((left, right) => {
+    const rightScore = relevanceById.get(right.id) ?? 0;
+    const leftScore = relevanceById.get(left.id) ?? 0;
+    if (rightScore !== leftScore) return rightScore - leftScore;
+    return sortMemoryForPrompt(left, right);
+  });
+  return { records: ranked, relevanceById, scored: true, degradedReason: null };
+}
+
+export interface BuildReviewedMemoryPromptOptions {
+  readonly limit?: number;
+  /** The current turn's raw text (the seam this comes from: TURN_SUBMITTED's `prompt`).
+   *  Used only to RANK the already-eligible set — never to admit an otherwise-ineligible record. */
+  readonly turnText?: string | null;
+}
+
+export function buildReviewedMemoryPrompt(memoryRegistry: MemoryRegistry, options: BuildReviewedMemoryPromptOptions = {}): string | null {
+  const limit = options.limit ?? DEFAULT_LIMIT;
+  const eligible = memoryRegistry.getAll().filter(isPromptActiveMemory);
+  const ranking = rankMemoryForTurn(memoryRegistry, eligible, options.turnText);
+  const records = ranking.records.slice(0, Math.max(0, limit));
 
   if (records.length === 0) return null;
   return [

package/src/agent/operator-actions.ts

@@ -6,14 +6,14 @@ export type JsonRecord = Record<string, unknown>;
 export type ApprovalActionId = 'approvals.approve' | 'approvals.deny' | 'approvals.cancel';
 export type AutomationActionId =
   | 'automation.jobs.run'
-  | 'automation.jobs.pause'
-  | 'automation.jobs.resume'
+  | 'automation.jobs.disable'
+  | 'automation.jobs.enable'
   | 'automation.runs.cancel'
   | 'automation.runs.retry'
-  | 'schedules.delete'
-  | 'schedules.disable'
-  | 'schedules.enable'
-  | 'schedules.run';
+  | 'automation.schedules.delete'
+  | 'automation.schedules.disable'
+  | 'automation.schedules.enable'
+  | 'automation.schedules.run';
 export type OperatorActionId = ApprovalActionId | AutomationActionId;
 export type OperatorActionHttpMethod = 'POST' | 'DELETE';
 
@@ -103,16 +103,20 @@ export const OPERATOR_ACTIONS: Record<OperatorActionId, OperatorActionDescriptor
     pathTemplate: '/api/automation/jobs/{jobId}/run',
     targetField: 'jobId',
   },
-  'automation.jobs.pause': {
-    action: 'automation.jobs.pause',
+  // W6-C3: automation.jobs.pause/resume were retired (redundant with
+  // disable/enable — same {id,enabled} output, same semantics). The
+  // user-facing "pause"/"resume" verb is unchanged; only the wire action +
+  // path moved to the canonical disable/enable methods.
+  'automation.jobs.disable': {
+    action: 'automation.jobs.disable',
     label: 'pause automation job',
-    pathTemplate: '/api/automation/jobs/{jobId}/pause',
+    pathTemplate: '/api/automation/jobs/{jobId}/disable',
     targetField: 'jobId',
   },
-  'automation.jobs.resume': {
-    action: 'automation.jobs.resume',
+  'automation.jobs.enable': {
+    action: 'automation.jobs.enable',
     label: 'resume automation job',
-    pathTemplate: '/api/automation/jobs/{jobId}/resume',
+    pathTemplate: '/api/automation/jobs/{jobId}/enable',
     targetField: 'jobId',
   },
   'automation.runs.cancel': {
@@ -127,26 +131,26 @@ export const OPERATOR_ACTIONS: Record<OperatorActionId, OperatorActionDescriptor
     pathTemplate: '/api/automation/runs/{runId}/retry',
     targetField: 'runId',
   },
-  'schedules.run': {
-    action: 'schedules.run',
+  'automation.schedules.run': {
+    action: 'automation.schedules.run',
     label: 'run schedule',
     pathTemplate: '/api/automation/schedules/{scheduleId}/run',
     targetField: 'scheduleId',
   },
-  'schedules.enable': {
-    action: 'schedules.enable',
+  'automation.schedules.enable': {
+    action: 'automation.schedules.enable',
     label: 'enable schedule',
     pathTemplate: '/api/automation/schedules/{scheduleId}/enable',
     targetField: 'scheduleId',
   },
-  'schedules.disable': {
-    action: 'schedules.disable',
+  'automation.schedules.disable': {
+    action: 'automation.schedules.disable',
     label: 'disable schedule',
     pathTemplate: '/api/automation/schedules/{scheduleId}/disable',
     targetField: 'scheduleId',
   },
-  'schedules.delete': {
-    action: 'schedules.delete',
+  'automation.schedules.delete': {
+    action: 'automation.schedules.delete',
     label: 'delete schedule',
     pathTemplate: '/api/automation/schedules/{scheduleId}',
     targetField: 'scheduleId',
@@ -340,14 +344,14 @@ function scheduleIdFromActionPath(path: string): string {
 }
 
 export function formatOperatorActionSuccess(baseUrl: string, result: OperatorActionSuccess): string {
-  const scheduleId = result.methodId.startsWith('schedules.') ? scheduleIdFromActionPath(result.path) : '';
+  const scheduleId = result.methodId.startsWith('automation.schedules.') ? scheduleIdFromActionPath(result.path) : '';
   return [
     'Agent operator action completed',
     `  method: ${result.methodId}`,
     `  route: ${result.httpMethod} ${result.path}`,
     `  connected host: ${baseUrl}`,
     `  status: ${statusFromOperatorActionBody(result.body)}`,
-    ...(scheduleId ? scheduleNextRouteLines(scheduleId, { deleted: result.methodId === 'schedules.delete' }) : []),
+    ...(scheduleId ? scheduleNextRouteLines(scheduleId, { deleted: result.methodId === 'automation.schedules.delete' }) : []),
   ].join('\n');
 }
 

package/src/agent/prompt-context-receipts.ts

@@ -1,10 +1,10 @@
 import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { dirname } from 'node:path';
-import type { MemoryRecord, MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
 import { getTierForContextWindow, getTierPromptSupplement } from '@pellux/goodvibes-sdk/platform/providers';
 import type { ShellPathService } from '@/runtime/index.ts';
-import { buildReviewedMemoryPrompt, isPromptActiveMemory, MIN_PROMPT_MEMORY_CONFIDENCE } from './memory-prompt.ts';
+import { buildReviewedMemoryPrompt, describeMemoryPromptEligibility, isPromptActiveMemory, rankMemoryForTurn, relevanceBand } from './memory-prompt.ts';
 import { AgentPersonaRegistry, buildActivePersonaPrompt } from './persona-registry.ts';
 import { buildProjectContextPrompt, discoverProjectContextFiles } from './project-context-files.ts';
 import { AgentRoutineRegistry, buildEnabledRoutinesPrompt, evaluateAgentRoutineReadiness } from './routine-registry.ts';
@@ -73,6 +73,10 @@ export interface RuntimePromptCompositionInput {
   readonly operatorPolicy: string;
   readonly shellPaths: ShellPathService;
   readonly memoryRegistry: MemoryRegistry;
+  /** The active turn's raw text (TURN_SUBMITTED's `prompt`), used only to rank the
+   *  already-eligible memory set by relevance to this turn — see rankMemoryForTurn.
+   *  Null/undefined when there is no active turn (e.g. a follow-up composition). */
+  readonly turnText?: string | null;
 }
 
 const RECEIPT_STORE_LIMIT = 200;
@@ -117,11 +121,6 @@ function statusFor(active: number, suppressed: number): PromptContextReceiptStat
   return 'empty';
 }
 
-function memorySort(left: MemoryRecord, right: MemoryRecord): number {
-  if (right.confidence !== left.confidence) return right.confidence - left.confidence;
-  return right.updatedAt - left.updatedAt;
-}
-
 function receiptSegment(input: Omit<PromptContextReceiptSegment, 'approxTokens'> & { readonly promptText?: string }): PromptContextReceiptSegment {
   const promptChars = input.promptText?.length ?? input.promptChars;
   return {
@@ -145,10 +144,12 @@ function buildRuntimePromptReceiptSegments(input: RuntimePromptCompositionInput)
   const projectContext = discoverProjectContextFiles(input.shellPaths);
   const projectContextPrompt = buildProjectContextPrompt(input.shellPaths) ?? '';
   const memoryRecords = input.memoryRegistry.getAll();
-  const activeMemory = memoryRecords.filter(isPromptActiveMemory).sort(memorySort).slice(0, 10);
+  const eligibleMemory = memoryRecords.filter(isPromptActiveMemory);
+  const memoryRanking = rankMemoryForTurn(input.memoryRegistry, eligibleMemory, input.turnText);
+  const activeMemory = memoryRanking.records.slice(0, 10);
   const activeMemoryIds = new Set(activeMemory.map((record) => record.id));
   const suppressedMemory = memoryRecords.filter((record) => !activeMemoryIds.has(record.id));
-  const memoryPrompt = buildReviewedMemoryPrompt(input.memoryRegistry) ?? '';
+  const memoryPrompt = buildReviewedMemoryPrompt(input.memoryRegistry, { turnText: input.turnText }) ?? '';
   const routineSnapshot = AgentRoutineRegistry.fromShellPaths(input.shellPaths).snapshot();
   const activeRoutines = routineSnapshot.enabledRoutines.filter((routine) => routine.reviewState === 'reviewed' && evaluateAgentRoutineReadiness(routine).ready);
   const suppressedRoutines = routineSnapshot.enabledRoutines.filter((routine) => !activeRoutines.some((active) => active.id === routine.id));
@@ -231,17 +232,43 @@ function buildRuntimePromptReceiptSegments(input: RuntimePromptCompositionInput)
       suppressedCount: suppressedMemory.length,
       promptChars: memoryPrompt.length,
       promptText: memoryPrompt,
-      selected: activeMemory.map((record) => ({ id: record.id, scope: record.scope, class: record.cls, confidence: record.confidence })),
-      suppressed: suppressedMemory.slice(0, 12).map((record) => ({
+      // Honest degrade note (Wave-4 W4-A1B): when per-turn relevance scoring did not
+      // run — no active-turn text, semantic index unavailable, or no vector match —
+      // say so instead of silently presenting the fallback confidence/recency order as
+      // if it were a relevance ranking.
+      note: memoryRanking.scored ? undefined : (memoryRanking.degradedReason ?? undefined),
+      selected: activeMemory.map((record) => ({
         id: record.id,
-        reviewState: record.reviewState,
+        scope: record.scope,
+        class: record.cls,
         confidence: record.confidence,
-        reason: record.reviewState !== 'reviewed'
-          ? 'not reviewed'
-          : record.confidence < MIN_PROMPT_MEMORY_CONFIDENCE
-            ? `confidence below ${MIN_PROMPT_MEMORY_CONFIDENCE}`
-            : 'outside prompt limit',
+        reason: describeMemoryPromptEligibility(record).reason,
+        // Per-turn relevance (W4-A1B): honest wording, only present when actually scored.
+        // F7a: the raw percent is paired with a qualitative band (see relevanceBand)
+        // so a genuinely-lower-but-real score like "28%" doesn't read as noise.
+        ...(memoryRanking.scored ? { relevance: `relevance to this turn: ${memoryRanking.relevanceById.get(record.id) ?? 0}% (${relevanceBand(memoryRanking.relevanceById.get(record.id) ?? 0)})` } : {}),
       })),
+      suppressed: suppressedMemory.slice(0, 12).map((record) => {
+        // Honest, per-record reason (confidence + reviewState + provenance) — never a
+        // blanket "not reviewed"/"outside prompt limit" guess. A record lands in
+        // "suppressed" either because it genuinely failed eligibility, or because it
+        // passed eligibility but the top-10 prompt slice cut it off — those are
+        // different situations and must read differently. When the slice was
+        // relevance-ranked, say what this record's relevance to the turn was too, so a
+        // budget-limited cut reads as "less relevant than the other ten", not arbitrary.
+        const eligibility = describeMemoryPromptEligibility(record);
+        const relevanceSuffix = memoryRanking.scored
+          ? ` (relevance to this turn: ${memoryRanking.relevanceById.get(record.id) ?? 0}% — ${relevanceBand(memoryRanking.relevanceById.get(record.id) ?? 0)})`
+          : '';
+        return {
+          id: record.id,
+          reviewState: record.reviewState,
+          confidence: record.confidence,
+          reason: eligibility.eligible
+            ? `eligible (${eligibility.reason}) but outside the top-10 prompt slice${relevanceSuffix} — budget-limited, not a trust problem`
+            : eligibility.reason,
+        };
+      }),
     }),
     receiptSegment({
       id: 'routines',
@@ -317,7 +344,7 @@ export function composeRuntimePromptWithReceipt(input: RuntimePromptCompositionI
     buildVibePrompt(input.shellPaths),
     buildProjectContextPrompt(input.shellPaths),
     input.operatorPolicy,
-    buildReviewedMemoryPrompt(input.memoryRegistry),
+    buildReviewedMemoryPrompt(input.memoryRegistry, { turnText: input.turnText }),
     buildEnabledRoutinesPrompt(input.shellPaths),
     buildEnabledSkillsPrompt(input.shellPaths),
     buildActivePersonaPrompt(input.shellPaths),

package/src/agent/reminder-schedule-format.ts

@@ -89,7 +89,7 @@ export function formatReminderScheduleFailure(failure: ReminderScheduleFailure):
       ? '  next make the connected GoodVibes host available outside Agent, then retry.'
       : null,
     failure.kind === 'connected_host_incompatible' || failure.kind === 'connected_host_route_unavailable'
-      ? '  next update the connected GoodVibes host so public schedules.create is available.'
+      ? '  next update the connected GoodVibes host so public automation.schedules.create is available.'
       : null,
   ].filter((line): line is string => Boolean(line)).join('\n');
 }

package/src/agent/reminder-schedule.ts

@@ -15,8 +15,8 @@ import {
   type RoutineScheduleSpec,
 } from './routine-schedule-promotion.ts';
 
-type ScheduleCreateInput = OperatorMethodInput<'schedules.create'>;
-type ScheduleCreateOutput = OperatorMethodOutput<'schedules.create'>;
+type ScheduleCreateInput = OperatorMethodInput<'automation.schedules.create'>;
+type ScheduleCreateOutput = OperatorMethodOutput<'automation.schedules.create'>;
 type ScheduleDeliveryInput = NonNullable<ScheduleCreateInput['delivery']>;
 type ScheduleDeliveryTargetInput = ScheduleDeliveryInput['targets'] extends readonly (infer T)[] ? T : never;
 
@@ -441,7 +441,7 @@ async function classifyReminderScheduleError(
       return {
         ok: false,
         kind: 'connected_host_incompatible',
-        error: 'Connected GoodVibes host compatibility does not satisfy Agent schedule requirements; schedules.create is unavailable.',
+        error: 'Connected GoodVibes host compatibility does not satisfy Agent schedule requirements; automation.schedules.create is unavailable.',
         route: REMINDER_SCHEDULE_ROUTE,
         baseUrl: connection.baseUrl,
       };

package/src/agent/routine-schedule-format.ts

@@ -166,7 +166,7 @@ export function formatRoutineScheduleCorrelation(result: RoutineScheduleCorrelat
         ? '  next make the connected GoodVibes host available outside Agent, then retry.'
         : null,
       result.kind === 'connected_host_incompatible' || result.kind === 'connected_host_route_unavailable'
-        ? '  next update the connected GoodVibes host so public schedules.list is available.'
+        ? '  next update the connected GoodVibes host so public automation.schedules.list is available.'
         : null,
     ].filter((line): line is string => Boolean(line)).join('\n');
   }
@@ -218,7 +218,7 @@ export function formatRoutineScheduleFailure(failure: RoutineSchedulePromotionFa
       ? '  next make the connected GoodVibes host available outside Agent, then retry.'
       : null,
     failure.kind === 'connected_host_incompatible' || failure.kind === 'connected_host_route_unavailable'
-      ? '  next update the connected GoodVibes host so public schedules.create is available.'
+      ? '  next update the connected GoodVibes host so public automation.schedules.create is available.'
       : null,
   ].filter((line): line is string => Boolean(line)).join('\n');
 }

package/src/agent/routine-schedule-promotion.ts

@@ -8,11 +8,11 @@ import { formatAgentRecordReviewState } from './record-labels.ts';
 import type { AgentRoutineRecord } from './routine-registry.ts';
 
 export const ROUTINE_SCHEDULE_ROUTE = '/api/automation/schedules';
-export const ROUTINE_SCHEDULE_METHOD = 'schedules.create';
-export const ROUTINE_SCHEDULE_LIST_METHOD = 'schedules.list';
+export const ROUTINE_SCHEDULE_METHOD = 'automation.schedules.create';
+export const ROUTINE_SCHEDULE_LIST_METHOD = 'automation.schedules.list';
 
-type ScheduleCreateInput = OperatorMethodInput<'schedules.create'>;
-type ScheduleCreateOutput = OperatorMethodOutput<'schedules.create'>;
+type ScheduleCreateInput = OperatorMethodInput<'automation.schedules.create'>;
+type ScheduleCreateOutput = OperatorMethodOutput<'automation.schedules.create'>;
 type ScheduleDeliveryInput = NonNullable<ScheduleCreateInput['delivery']>;
 type ScheduleDeliveryTargetInput = ScheduleDeliveryInput['targets'] extends readonly (infer T)[] ? T : never;
 
@@ -388,7 +388,7 @@ async function classifyScheduleError(
       return {
         ok: false,
         kind: 'connected_host_incompatible',
-        error: 'Connected GoodVibes host compatibility does not satisfy Agent schedule requirements; schedules.create is unavailable.',
+        error: 'Connected GoodVibes host compatibility does not satisfy Agent schedule requirements; automation.schedules.create is unavailable.',
         route: ROUTINE_SCHEDULE_ROUTE,
         baseUrl: connection.baseUrl,
       };

package/src/agent/routine-schedule-receipts.ts

@@ -28,7 +28,7 @@ import {
 
 type ScheduleCreateInput = RoutineSchedulePromotionPreview['payload'];
 type ScheduleDeliveryInput = NonNullable<ScheduleCreateInput['delivery']>;
-type ScheduleListOutput = OperatorMethodOutput<'schedules.list'>;
+type ScheduleListOutput = OperatorMethodOutput<'automation.schedules.list'>;
 
 interface RoutineScheduleReceiptStoreFile {
   readonly version: 1;
@@ -453,7 +453,7 @@ async function classifyScheduleListError(
       return {
         ok: false,
         kind: 'connected_host_incompatible',
-        error: 'Connected GoodVibes host compatibility does not satisfy Agent schedule requirements; schedules.list is unavailable.',
+        error: 'Connected GoodVibes host compatibility does not satisfy Agent schedule requirements; automation.schedules.list is unavailable.',
         route: ROUTINE_SCHEDULE_ROUTE,
         baseUrl: connection.baseUrl,
       };

package/src/agent/schedule-edit-format.ts

@@ -123,7 +123,7 @@ export function formatScheduleEditFailure(failure: ScheduleEditFailure): string
       ? '  next pair or start the connected GoodVibes host so an operator token is available.'
       : '',
     failure.kind === 'connected_host_incompatible'
-      ? '  next update the connected GoodVibes host so automation.jobs.patch is available.'
+      ? '  next update the connected GoodVibes host so automation.jobs.update is available.'
       : '',
   ].filter((line) => line !== '').join('\n');
 }

package/src/agent/schedule-edit.ts

@@ -21,11 +21,11 @@ import {
   type RoutineScheduleSpec,
 } from './routine-schedule-promotion.ts';
 
-type SchedulePatchInput = OperatorMethodInput<'automation.jobs.patch'>;
-type SchedulePatchOutput = OperatorMethodOutput<'automation.jobs.patch'>;
-type ScheduleListOutput = OperatorMethodOutput<'schedules.list'>;
+type SchedulePatchInput = OperatorMethodInput<'automation.jobs.update'>;
+type SchedulePatchOutput = OperatorMethodOutput<'automation.jobs.update'>;
+type ScheduleListOutput = OperatorMethodOutput<'automation.schedules.list'>;
 
-export const SCHEDULE_EDIT_METHOD = 'automation.jobs.patch';
+export const SCHEDULE_EDIT_METHOD = 'automation.jobs.update';
 export const SCHEDULE_EDIT_ROUTE = '/api/automation/jobs/{jobId}';
 
 export interface ParsedScheduleEditArgs {
@@ -442,7 +442,7 @@ async function classifyScheduleEditError(
       return {
         ok: false,
         kind: 'connected_host_incompatible',
-        error: 'Connected GoodVibes host compatibility does not satisfy Agent schedule edit requirements; automation.jobs.patch is unavailable.',
+        error: 'Connected GoodVibes host compatibility does not satisfy Agent schedule edit requirements; automation.jobs.update is unavailable.',
         route: SCHEDULE_EDIT_ROUTE,
         baseUrl: connection.baseUrl,
       };