@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/shell/agent-workspace-fullscreen.ts

@@ -36,5 +36,10 @@ export function createAgentWorkspaceFullscreenComposite(
   width: number,
   height: number,
 ): CompositeRequest {
+  // W4-A6: mirror disk state on every repaint of the workspace panel so the
+  // memory count and routine start counts never show a stale point-in-time
+  // snapshot from the last workspace action (e.g. an external delete, or a
+  // routine started from another shell/CLI invocation).
+  workspace.syncLiveCountersForRender();
   return createFullscreenCompositeFromLines(renderAgentWorkspace(workspace, width, height), width, height);
 }

package/src/shell/terminal-focus-mode.ts

@@ -0,0 +1,120 @@
+/**
+ * terminal-focus-mode.ts — W4-R3: DECSET ?1004h OS window-focus reporting +
+ * the approval-alert wiring that consumes it.
+ *
+ * Extracted from main.ts (architecture line-count gate: MAX_SOURCE_LINES=800
+ * in scripts/check-architecture.ts) — mirrors goodvibes-tui's own precedent of
+ * extracting terminal-mode literals out of its entry file (see that repo's
+ * src/renderer/terminal-escapes.ts docstring). Behavior is unchanged from an
+ * inline version; this is purely a line-count extraction plus the one new
+ * behavior (the approval alert) this work order adds.
+ *
+ * FOCUS_ENABLE/FOCUS_DISABLE: sourced from W4-R2's terminal-escapes.ts (the
+ * shared home for the DECSET ?1004 literals — its own docstring names R3 as
+ * the importer) and re-exported here so the focus-mode callers (main.ts and
+ * the tests) keep one import site for the whole focus-mode surface. This is
+ * the R2/R3 convergence the W4-R1 parity matrix pre-ruled: a relocation of
+ * the literals, no behavior change.
+ *
+ * installFocusModeExitGuard(): a last-resort safety net. Node/Bun fire 'exit'
+ * listeners synchronously for every process-termination path this app can
+ * take — explicit process.exit() calls (normal /exit, double-Ctrl+C via
+ * exitApp()) AND the default uncaughtException termination — even though
+ * main.ts registers no explicit uncaughtException/SIGTERM handler of its own.
+ * Named top-5 risk (W4-R1 matrix): ?1004h MUST be disabled on every exit path
+ * or the user's shell inherits focus-reporting escape garbage. The write is
+ * harmless even if exitApp() already disabled it moments earlier (?1004l is
+ * idempotent). It is GATED on focus mode having actually been enabled
+ * (markFocusModeEnabled, called at the TUI's ?1004h-enable site): only the
+ * interactive TUI launch turns focus reporting on, so a blocked/scriptable
+ * command (serve/status/--help/…) that exits before that must leave stdout
+ * pristine — a stray ?1004l on such a command's stdout is escape garbage that
+ * would, e.g., corrupt `status --json` for a machine consumer.
+ *
+ * wrapRequestPermissionWithApprovalAlert(): fires an unfocused-user alert the
+ * moment a tool call becomes a real, user-blocking permission prompt. Ported
+ * concept from goodvibes-tui's core/approval-alert.ts, scoped down: that
+ * module's config-gated alert-class system (alert-gating.ts's
+ * behavior.notifyOnApprovalPending / notifyOnlyWhenUnfocused settings, shared
+ * with budget-breach/long-task/chain-failure notifiers) is TUI-specific
+ * infrastructure the W4-R1 parity matrix does not list as a PORT item — only
+ * core/focus-tracker.ts is. This is the minimal, self-contained wiring the
+ * matrix's own text calls for ("route focus in/out events ... to drive
+ * awaiting-approval alerts"). PRIVACY: message content is tool name + category
+ * only — no args, no file contents, no command strings.
+ */
+import { logger, notifyCompletion, summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { PermissionRequestHandler, PermissionPromptRequest } from '@pellux/goodvibes-sdk/platform/permissions';
+import type { FocusTracker } from '../core/focus-tracker.ts';
+
+import { FOCUS_DISABLE } from '../renderer/terminal-escapes.ts';
+export { FOCUS_ENABLE, FOCUS_DISABLE } from '../renderer/terminal-escapes.ts';
+
+/**
+ * notifyCompletion (SDK platform/utils) only rings the bell above 5s of
+ * "duration" and only pops a desktop notification above 30s — a heuristic
+ * tuned for long-running-turn notifications (ported alongside
+ * goodvibes-tui's alert-gating.ts FORCE_NOTIFY_DURATION_MS). The
+ * approval-alert wire is a point-in-time event with no natural duration, so
+ * it passes this constant as durationMs to force both the bell and the
+ * desktop popup unconditionally.
+ */
+export const FORCE_APPROVAL_NOTIFY_DURATION_MS = 30_001;
+
+/**
+ * Whether the TUI actually enabled OS focus reporting (DECSET ?1004h) this run.
+ * Set once, at the TUI launch site that writes FOCUS_ENABLE; the process exits
+ * without ever clearing it, so the teardown guard fires on every abnormal-exit
+ * path once focus mode is on. Left false by every blocked/scriptable command.
+ */
+let focusModeEnabled = false;
+
+/** Record that OS focus reporting was enabled; call at the same site that writes FOCUS_ENABLE. */
+export function markFocusModeEnabled(): void {
+  focusModeEnabled = true;
+}
+
+/**
+ * Registers the process-wide ?1004h teardown safety net. Call once at startup.
+ * The write only fires when focus mode was actually enabled (isFocusModeEnabled),
+ * so non-TUI commands never leak ?1004l onto stdout. The predicate is injectable
+ * so tests can drive both branches deterministically without module-global state.
+ */
+export function installFocusModeExitGuard(
+  stdout: Pick<NodeJS.WriteStream, 'write'> = process.stdout,
+  isFocusModeEnabled: () => boolean = () => focusModeEnabled,
+): void {
+  process.on('exit', () => {
+    if (!isFocusModeEnabled()) return; // never enabled (blocked/scriptable command) — keep stdout clean
+    try { stdout.write(FOCUS_DISABLE); } catch { /* stdout may already be torn down */ }
+  });
+}
+
+export interface ApprovalAlertDeps {
+  readonly focusTracker: Pick<FocusTracker, 'shouldAlertWhenUnfocused'>;
+  readonly notify?: typeof notifyCompletion;
+}
+
+/**
+ * Wrap a PermissionRequestHandler so every call also fires an unfocused-user
+ * alert. The wrapped handler's behavior (what it resolves to) is completely
+ * unchanged — this only adds a side effect at call time, fired synchronously
+ * before the wrapped promise settles (reflects "a prompt just appeared", not
+ * "a prompt was just resolved").
+ */
+export function wrapRequestPermissionWithApprovalAlert(
+  original: PermissionRequestHandler,
+  deps: ApprovalAlertDeps,
+): PermissionRequestHandler {
+  const notify = deps.notify ?? notifyCompletion;
+  return (request: PermissionPromptRequest) => {
+    if (deps.focusTracker.shouldAlertWhenUnfocused()) {
+      try {
+        notify('GoodVibes — approval needed', `${request.tool} (${request.category}) is waiting for approval`, FORCE_APPROVAL_NOTIFY_DURATION_MS);
+      } catch (err) {
+        logger.debug('approval-alert: desktop notify error', { error: summarizeError(err) });
+      }
+    }
+    return original(request);
+  };
+}

package/src/shell/ui-openers.ts

@@ -14,6 +14,7 @@ import type { ServiceInspectionQuery } from '../runtime/ui-service-queries.ts';
 import type { ModelPickerTargetInfo } from '../input/model-picker.ts';
 import { buildLocalFitRecommendations, buildSignInRow, LOCAL_REC_PROVIDER } from '../input/model-picker-local-fit.ts';
 import { syncServiceSettingToPlatform } from './service-settings-sync.ts';
+import { applyThemeModeSettingChange, THEME_MODE_CONFIG_KEY } from '../renderer/theme-mode-config.ts';
 
 type WireShellUiOpenersOptions = {
   commandContext: CommandContext;
@@ -422,10 +423,18 @@ export function wireShellUiOpeners(options: WireShellUiOpenersOptions): void {
   commandContext.openSettingsModal = (target?: string) => {
     input.modalOpened('settings');
     input.settingsModal.open(configManager, featureFlags, subscriptionManager, serviceRegistry, mcpRegistry, secretsManager, {
-      onSettingApplied: (change) => syncServiceSettingToPlatform(
-        { configManager, workingDirectory, homeDirectory },
-        change,
-      ),
+      onSettingApplied: (change) => {
+        // W4-R4: forced dark/light applies immediately (mode flip + full
+        // repaint via clearScreen's resetDiff); auto only re-probes at startup,
+        // so it takes effect next launch (stated honestly).
+        if (String(change.key) === THEME_MODE_CONFIG_KEY) {
+          return applyThemeModeSettingChange(change.value, () => commandContext.clearScreen?.());
+        }
+        return syncServiceSettingToPlatform(
+          { configManager, workingDirectory, homeDirectory },
+          change,
+        );
+      },
     });
     input.settingsModal.selectTarget(target);
     render();

package/src/tools/agent-harness-autonomy-intake.ts

@@ -417,8 +417,8 @@ function asksForEventTrigger(lower: string): boolean {
 
 function buildTriggerWorkflows(request: string, schedule: ScheduleDetection): readonly TriggerWorkflow[] {
   const methodIds = operatorMethodIds();
-  const schedulesCreatePublished = methodIds.has('schedules.create');
-  const schedulesListPublished = methodIds.has('schedules.list');
+  const schedulesCreatePublished = methodIds.has('automation.schedules.create');
+  const schedulesListPublished = methodIds.has('automation.schedules.list');
   const watcherCreatePublished = methodIds.has('watchers.create');
   const watcherListPublished = methodIds.has('watchers.list');
   const watcherRunPublished = methodIds.has('watchers.run');
@@ -437,10 +437,10 @@ function buildTriggerWorkflows(request: string, schedule: ScheduleDetection): re
       status: scheduleReady ? 'ready' : schedulesCreatePublished ? 'attention' : 'setup-needed',
       userOutcome: 'Run autonomous work on an exact at/every/cron cadence without making the user understand scheduler internals.',
       summary: scheduleReady
-        ? 'The request includes an exact cadence and the connected host publishes schedules.create.'
+        ? 'The request includes an exact cadence and the connected host publishes automation.schedules.create.'
         : schedulesCreatePublished
           ? 'The schedule route is published, but this request still needs an exact cadence before creation.'
-          : 'The connected host does not publish schedules.create in the current SDK contract.',
+          : 'The connected host does not publish automation.schedules.create in the current SDK contract.',
       nextStep: scheduleReady
         ? 'Create through schedule action:"create" with confirm:true and explicit success criteria.'
         : 'Ask for the exact ISO time, every interval, or cron expression before offering schedule creation.',
@@ -449,7 +449,7 @@ function buildTriggerWorkflows(request: string, schedule: ScheduleDetection): re
       modelRoute: `schedule action:"create" task:"${shortRequest}" successCriteria:"..." scheduleKind:"${schedule.kind ?? 'at|every|cron'}" scheduleValue:"${schedule.value ?? '...'}" confirm:true explicitUserRequest:"..."`,
       inspectRoute: 'autonomy action:"item" queueItemId:"connected-schedules"',
       setupRoutes: [
-        'host action:"method" methodId:"schedules.create"',
+        'host action:"method" methodId:"automation.schedules.create"',
         'autonomy action:"item" queueItemId:"connected-schedules"',
       ],
       evidence: {

package/src/tools/agent-harness-autonomy-queue.ts

@@ -381,7 +381,7 @@ function buildQueueItems(context: CommandContext): readonly AutonomyQueueItem[]
       current: `${scheduleMethods.length} schedule/reminder daemon method(s); autonomous schedules require explicit task, cadence, success criteria, and user request provenance.`,
       next: scheduleMethods.length > 0
         ? 'Create one visible autonomous schedule only after the user gives exact timing and success criteria.'
-        : 'Update the connected GoodVibes host until schedules.create is available.',
+        : 'Update the connected GoodVibes host until automation.schedules.create is available.',
       inspectRoute: 'autonomy action:"intake" query:"..."',
       modelRoute: 'schedule action:"create"',
       createRoute: 'schedule action:"create" task:"..." successCriteria:"..." scheduleKind:"..." scheduleValue:"..." confirm:true explicitUserRequest:"..."',

package/src/tools/agent-harness-background-processes.ts

@@ -104,7 +104,8 @@ function matchingOperatorMethodRoutes(tokens: readonly string[]): readonly Recor
   return operatorContractMethods()
     .filter((method) => {
       const text = operatorMethodSearchText(method);
-      return tokens.some((token) => text.includes(token));
+      // \b-anchored: a raw text.includes(token) false-matches short tokens like 'pty' inside an unrelated word ('empty').
+      return tokens.some((token) => new RegExp(`\\b${token.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\b`).test(text));
     })
     .map((method) => ({
       methodId: method.id,

package/src/tools/agent-harness-metadata.ts

@@ -86,6 +86,14 @@ export function describeCommandPolicy(commandName: string): CommandExecutionPoli
       boundary: 'Provider selection and custom provider files belong to Agent provider configuration. Adding, removing, or switching providers requires explicit user intent.',
     };
   }
+  if (root === 'network-scan' || root === 'discover-lan') {
+    return {
+      effect: 'local-state',
+      confirmation,
+      preferredModelTool: settingsActions('get', 'set'),
+      boundary: 'Turns the local-network model-server scan on or off and persists that decision to a local consent file; it never probes the network itself. Enabling it requires the user\'s explicit request — do not turn it on unprompted.',
+    };
+  }
   if (root === 'refresh-models') {
     return {
       effect: 'external-network',
@@ -387,14 +395,14 @@ export function connectedHostCapabilityMap(toolRegistry: ToolRegistry): readonly
         'approvals.deny',
         'approvals.cancel',
         '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',
       ],
       purpose: 'Perform one explicit allowlisted approval, automation, run, or schedule action.',
     }),
@@ -404,7 +412,7 @@ export function connectedHostCapabilityMap(toolRegistry: ToolRegistry): readonly
       modelTools: ['schedule', 'agent_schedule_edit'],
       workspaceCategories: ['automation', 'personal-ops'],
       slashCommandFamilies: ['schedule'],
-      methodIds: ['automation.jobs.patch'],
+      methodIds: ['automation.jobs.update'],
       purpose: 'Edit one explicit connected schedule name, cadence, or prompt.',
     }),
     withAvailability({
@@ -737,6 +745,6 @@ export function settingsPolicySummary(): Record<string, unknown> {
     mutation: 'Use settings action:"set" or action:"reset" with key, target, or query plus confirm:true and explicitUserRequest; ambiguous setting lookups are refused.',
     secretHandling: 'Raw secret values are persisted through the secret manager; config receives only a secret reference and tool output is redacted.',
     writablePolicy: 'Each setting descriptor includes writable, visibleInWorkspace, and lockReason when applicable.',
-    protectedRawDangerKeys: ['danger.daemon', 'danger.httpListener'],
+    protectedRawDangerKeys: ['danger.httpListener'],
   };
 }

package/src/tools/agent-harness-operator-methods.ts

@@ -43,9 +43,35 @@ interface OperatorMethodDescriptor {
   readonly category: string;
   readonly access: string;
   readonly scopes: readonly string[];
+  readonly available: boolean;
   readonly parameters?: readonly Record<string, unknown>[];
 }
 
+/**
+ * W4-A3 (capability-advertisement honesty): the SDK operator contract marks
+ * a method `invokable: false` when it is cataloged but not backed by a real
+ * daemon route (see @pellux/goodvibes-sdk's method-catalog-route-reconcile —
+ * email.inbox.list/read, email.draft.create, email.send are the dogfood
+ * case: they advertise /api/email/* paths no router dispatch chain serves).
+ * Before this, `invokable` was declared on the local contract-method shape
+ * but never read — an unavailable method looked identical to a live one in
+ * this catalog, so the model (or a human skimming host action:"methods")
+ * had no way to tell the ad from the reality short of trying the call and
+ * getting a 404. Degrading the listing here means the ad itself — not just
+ * the eventual answer — tells the truth.
+ */
+function methodIsAvailable(method: OperatorContractMethod): boolean {
+  return method.invokable !== false;
+}
+
+const UNAVAILABLE_MODEL_TOOL = 'none — unavailable; do not call this method';
+const UNAVAILABLE_CONFIRMATION = 'Unavailable: cataloged by the daemon but not backed by a served route. Do not call it; it will not succeed.';
+const UNAVAILABLE_BOUNDARY = 'This method is advertised in the operator contract but the daemon does not currently serve its route (invokable:false). Treat it as absent — do not attempt to call it, and tell the user the capability is not wired up rather than guessing at a workaround.';
+
+function unavailableLabel(method: OperatorContractMethod): string {
+  return `${method.id} — unavailable (route not served by this daemon)`;
+}
+
 type OperatorMethodResolution =
   | { readonly status: 'found'; readonly method: Record<string, unknown> }
   | { readonly status: 'ambiguous'; readonly input: string; readonly candidates: readonly Record<string, unknown>[] }
@@ -121,22 +147,26 @@ function toDescriptor(method: OperatorContractMethod): OperatorMethodDescriptor
   const httpMethod = method.http?.method?.toUpperCase() ?? 'GET';
   const path = method.http?.path ?? '/';
   const effect = methodEffect(method);
-  const label = method.title ?? method.description ?? method.id;
+  const available = methodIsAvailable(method);
+  const label = available ? (method.title ?? method.description ?? method.id) : unavailableLabel(method);
   return {
     id: method.id,
     label,
     route: `${httpMethod} ${path}`,
     effect,
     owner: 'goodvibes-daemon',
-    preferredModelTool: preferredToolFor(effect),
-    confirmation: confirmationFor(effect),
-    boundary: effect === 'read-only-network'
-      ? 'Reads the connected GoodVibes daemon operator route and returns a redacted response.'
-      : 'Runs a confirmed connected GoodVibes daemon operator route. The model must keep the action visible, reversible when possible, and tied to the user request.',
+    preferredModelTool: available ? preferredToolFor(effect) : UNAVAILABLE_MODEL_TOOL,
+    confirmation: available ? confirmationFor(effect) : UNAVAILABLE_CONFIRMATION,
+    boundary: available
+      ? (effect === 'read-only-network'
+        ? 'Reads the connected GoodVibes daemon operator route and returns a redacted response.'
+        : 'Runs a confirmed connected GoodVibes daemon operator route. The model must keep the action visible, reversible when possible, and tied to the user request.')
+      : UNAVAILABLE_BOUNDARY,
     category: method.category ?? 'uncategorized',
     access: method.access ?? 'authenticated',
     scopes: method.scopes ?? [],
-    parameters: parametersFromInputSchema(method),
+    available,
+    parameters: available ? parametersFromInputSchema(method) : [],
   };
 }
 
@@ -170,6 +200,7 @@ function describeMethod(
     effect: method.effect,
     owner: method.owner,
     route: method.route,
+    available: method.available,
     modelRoute: previewHarnessText(method.preferredModelTool),
     scopes: method.scopes,
     confirmation: method.confirmation,
@@ -190,6 +221,7 @@ function describeCandidate(method: OperatorMethodDescriptor): Record<string, unk
     category: method.category,
     effect: method.effect,
     route: method.route,
+    available: method.available,
     modelRoute: previewHarnessText(method.preferredModelTool),
   };
 }
@@ -209,14 +241,18 @@ export function operatorMethodCatalogStatus(): Record<string, unknown> {
     acc[method.category] = (acc[method.category] ?? 0) + 1;
     return acc;
   }, {});
+  const unavailableMethods = methods.filter((method) => !method.available).length;
   return {
     modes: ['operator_methods', 'operator_method'],
     methods: methods.length,
     readOnlyMethods: methods.filter((method) => method.effect === 'read-only-network').length,
     confirmedMethods: methods.filter((method) => method.effect !== 'read-only-network').length,
     adminMethods: methods.filter((method) => method.effect === 'confirmed-admin-connected-host-state').length,
+    unavailableMethods,
     categories,
-    policy: 'Full GoodVibes SDK operator contract. Read-only routes can run through agent_operator_method; write/admin routes require confirm:true and explicitUserRequest.',
+    policy: unavailableMethods > 0
+      ? `Full GoodVibes SDK operator contract. Read-only routes can run through agent_operator_method; write/admin routes require confirm:true and explicitUserRequest. ${unavailableMethods} cataloged method(s) are currently unavailable (no served route) — check each method's "available" field before treating it as callable.`
+      : 'Full GoodVibes SDK operator contract. Read-only routes can run through agent_operator_method; write/admin routes require confirm:true and explicitUserRequest.',
   };
 }
 

package/src/tools/agent-harness-personal-ops-discovery.ts

@@ -35,17 +35,56 @@ export function methodSearchText(method: OperatorContractMethod): string {
   ].filter(Boolean).join('\n').toLowerCase();
 }
 
-export function methodIdsMatching(tokens: readonly string[]): readonly string[] {
+/**
+ * W4-A3/W4-A5 capability honesty: a method whose contract entry carries
+ * invokable:false is cataloged but NOT dispatchable — no daemon route or
+ * handler serves it. Counting it toward "workflow ready" would repeat the
+ * dogfood finding (a lane card claiming readiness backed only by methods a
+ * caller cannot actually invoke). Absent flag = invokable (older contracts).
+ */
+export function isInvokableContractMethod(method: OperatorContractMethod): boolean {
+  return method.invokable !== false;
+}
+
+function matchingContractMethods(tokens: readonly string[]): readonly OperatorContractMethod[] {
   if (tokens.length === 0) return [];
-  return operatorContractMethods()
-    .filter((method) => {
-      const text = methodSearchText(method);
-      return tokens.some((token) => text.includes(token));
-    })
+  return operatorContractMethods().filter((method) => {
+    const text = methodSearchText(method);
+    return tokens.some((token) => text.includes(token));
+  });
+}
+
+/**
+ * Method ids matching the tokens that are actually DISPATCHABLE. Readiness
+ * (workflowStatus, lane status, capability counts) must be computed from
+ * this list only — advertised-but-unavailable methods are returned
+ * separately by unavailableMethodIdsMatching for honest degraded wording.
+ */
+export function methodIdsMatching(tokens: readonly string[]): readonly string[] {
+  return matchingContractMethods(tokens)
+    .filter(isInvokableContractMethod)
     .map((method) => method.id)
     .sort((left, right) => left.localeCompare(right));
 }
 
+/** Method ids matching the tokens that are cataloged but NOT dispatchable (invokable:false). */
+export function unavailableMethodIdsMatching(tokens: readonly string[]): readonly string[] {
+  return matchingContractMethods(tokens)
+    .filter((method) => !isInvokableContractMethod(method))
+    .map((method) => method.id)
+    .sort((left, right) => left.localeCompare(right));
+}
+
+/**
+ * One honest line naming advertised-but-undispatchable methods, matching the
+ * W4-A3 degraded-ad pattern ("unavailable (route not served by this daemon)").
+ * Returns null when nothing is degraded.
+ */
+export function unavailableMethodsNote(unavailableMethodIds: readonly string[]): string | null {
+  if (unavailableMethodIds.length === 0) return null;
+  return `${unavailableMethodIds.length} advertised method(s) are unavailable (route not served by this daemon) and cannot be dispatched: ${unavailableMethodIds.join(', ')}.`;
+}
+
 export function mcpServerRecords(context: CommandContext): readonly {
   readonly name: string;
   readonly connected: boolean;
@@ -337,14 +376,18 @@ export function workflowInspectRoutes(methodIds: readonly string[], connectors:
   return routes.length > 0 ? routes : [`personal_ops action:"lane" laneId:"${fallbackQuery}"`];
 }
 
-export function inboxWorkflows(methodIds: readonly string[], connectors: readonly PersonalOpsConnectorSignal[]): readonly PersonalOpsWorkflow[] {
+export function inboxWorkflows(methodIds: readonly string[], connectors: readonly PersonalOpsConnectorSignal[], unavailableMethodIds: readonly string[] = []): readonly PersonalOpsWorkflow[] {
   const status = workflowStatus(methodIds, connectors);
   const inspectRoutes = workflowInspectRoutes(methodIds, connectors, 'inbox');
   const modelRoute = workflowModelRoute('email', connectors);
   const readToolCount = connectorToolCount(connectors, 'read-only');
   const writeToolCount = connectorToolCount(connectors, 'confirmed-effect');
+  const degradedAdNote = unavailableMethodsNote(unavailableMethodIds);
   const setupPrerequisite = status === 'needs-setup'
-    ? ['Install or configure an email-capable daemon method, MCP server, or plugin first.']
+    ? [
+      'Install or configure an email-capable daemon method, MCP server, or plugin first.',
+      ...(degradedAdNote ? [degradedAdNote] : []),
+    ]
     : status === 'attention'
       ? ['Review connector trust/schema freshness before reading inbox data.']
       : [
@@ -389,14 +432,18 @@ export function inboxWorkflows(methodIds: readonly string[], connectors: readonl
   ];
 }
 
-export function calendarWorkflows(methodIds: readonly string[], connectors: readonly PersonalOpsConnectorSignal[]): readonly PersonalOpsWorkflow[] {
+export function calendarWorkflows(methodIds: readonly string[], connectors: readonly PersonalOpsConnectorSignal[], unavailableMethodIds: readonly string[] = []): readonly PersonalOpsWorkflow[] {
   const status = workflowStatus(methodIds, connectors);
   const inspectRoutes = workflowInspectRoutes(methodIds, connectors, 'calendar');
   const modelRoute = workflowModelRoute('calendar', connectors);
   const readToolCount = connectorToolCount(connectors, 'read-only');
   const writeToolCount = connectorToolCount(connectors, 'confirmed-effect');
+  const degradedAdNote = unavailableMethodsNote(unavailableMethodIds);
   const setupPrerequisite = status === 'needs-setup'
-    ? ['Install or configure a calendar-capable daemon method, CalDAV MCP server, or plugin first.']
+    ? [
+      'Install or configure a calendar-capable daemon method, CalDAV MCP server, or plugin first.',
+      ...(degradedAdNote ? [degradedAdNote] : []),
+    ]
     : status === 'attention'
       ? ['Review connector trust/schema freshness before reading calendar data.']
       : [

package/src/tools/agent-harness-personal-ops-lanes.ts

@@ -1,6 +1,6 @@
 import type { CommandContext } from '../input/command-registry.ts';
 import { buildAgentWorkspaceRuntimeSnapshot } from '../input/agent-workspace-snapshot.ts';
-import { calendarWorkflows, connectorSignalsMatching, inboxWorkflows, methodIdsMatching, reminderWorkflows, taskWorkflows } from './agent-harness-personal-ops-discovery.ts';
+import { calendarWorkflows, connectorSignalsMatching, inboxWorkflows, methodIdsMatching, reminderWorkflows, taskWorkflows, unavailableMethodIdsMatching } from './agent-harness-personal-ops-discovery.ts';
 import { providerBackedQueueRecords } from './agent-harness-personal-ops-provider-records.ts';
 import { providerBackedReminderRecords, providerBackedTaskRecords } from './agent-harness-personal-ops-provider-task-records.ts';
 import { channelRecords, connectorRecords, localRecord, refreshableSavedRecordCount, reminderOperationRecords, routineReceiptRecord, savedProviderEffectReceiptRecords, savedReviewArtifactRecords, savedReviewQueueRecords, taskOperationRecords } from './agent-harness-personal-ops-records.ts';
@@ -15,8 +15,14 @@ export function buildLanes(
   } = {},
 ): readonly PersonalOpsLane[] {
   const snapshot = buildAgentWorkspaceRuntimeSnapshot(context);
+  // Readiness counts only DISPATCHABLE methods (W4-A3/W4-A5 honesty): a
+  // method the contract marks invokable:false has no serving route, so it
+  // must not make a lane read "ready"/"partial". The unavailable lists feed
+  // honest degraded wording instead.
   const emailMethods = methodIdsMatching(['email', 'mail', 'imap', 'smtp']);
+  const unavailableEmailMethods = unavailableMethodIdsMatching(['email', 'mail', 'imap', 'smtp']);
   const calendarMethods = methodIdsMatching(['calendar', 'caldav', 'agenda']);
+  const unavailableCalendarMethods = unavailableMethodIdsMatching(['calendar', 'caldav', 'agenda']);
   const toolsByName = options.toolsByServer ?? new Map<string, readonly McpToolRecord[]>();
   const schemasByQualifiedName = options.schemasByQualifiedName ?? new Map<string, McpToolSchema>();
   const emailConnectors = connectorSignalsMatching(context, ['email', 'mail', 'imap', 'smtp', 'gmail'], { lane: 'inbox', toolsByServer: toolsByName, schemasByQualifiedName });
@@ -66,6 +72,8 @@ export function buildLanes(
             ? 'Saved inbox review artifacts and thread queue items are available for recap, local draft review, or promotion; no fresh email connector is currently ready.'
             : inboxEffectReceiptRecords.length > 0
               ? 'Saved inbox provider-effect receipts are available for audit and follow-up; no fresh email connector is currently ready.'
+        : unavailableEmailMethods.length > 0
+          ? `The operator contract advertises ${unavailableEmailMethods.length} email method(s), but they are unavailable (route not served by this daemon) and cannot be dispatched.`
         : 'No email/IMAP/SMTP methods are present in the current GoodVibes SDK operator contract.',
       next: inboxProviderRecords.length > 0
         ? 'Inspect one fresh thread record, summarize or draft locally, and use only the published confirmed follow-up routes for replies, sends, labels, or archive.'
@@ -82,7 +90,8 @@ export function buildLanes(
       modelRoute: emailConnectors.length > 0 ? 'agent_harness mode:"mcp_servers" query:"email"' : 'host action:"methods" query:"email"',
       signals: [
         `${inboxProviderRecords.length} fresh provider-backed inbox thread record(s)`,
-        `${emailMethods.length} email-like daemon method(s)`,
+        `${emailMethods.length} dispatchable email-like daemon method(s)`,
+        ...(unavailableEmailMethods.length > 0 ? [`${unavailableEmailMethods.length} advertised-but-unavailable email method(s) (route not served by this daemon)`] : []),
         `${emailConnectors.length} email-like MCP connector(s)`,
         `${inboxArtifactRecords.length} saved inbox review artifact(s)`,
         `${inboxReviewQueueRecords.length} saved inbox thread queue item(s)`,
@@ -92,7 +101,7 @@ export function buildLanes(
       ],
       methodIds: emailMethods,
       connectorSignals: emailConnectors,
-      workflows: [...inboxWorkflows(emailMethods, emailConnectors), styleReplyAdditions.workflow],
+      workflows: [...inboxWorkflows(emailMethods, emailConnectors, unavailableEmailMethods), styleReplyAdditions.workflow],
       liveRecords: [
         ...inboxProviderRecords,
         ...inboxReviewQueueRecords,
@@ -119,6 +128,8 @@ export function buildLanes(
             ? 'Saved calendar review artifacts and event queue items are available for agenda recap, reminder creation, or follow-up planning; no fresh calendar connector is currently ready.'
             : calendarEffectReceiptRecords.length > 0
               ? 'Saved calendar provider-effect receipts are available for audit and follow-up; no fresh calendar connector is currently ready.'
+        : unavailableCalendarMethods.length > 0
+          ? `The operator contract advertises ${unavailableCalendarMethods.length} calendar method(s), but they are unavailable (route not served by this daemon) and cannot be dispatched. The local Agent calendar (/calendar) remains available.`
         : 'No calendar/CalDAV/agenda methods are present in the current GoodVibes SDK operator contract.',
       next: calendarProviderRecords.length > 0
         ? 'Inspect one fresh event record, brief the agenda or conflicts locally, and use only the published confirmed follow-up routes for edits, RSVP, reschedule, or delete.'
@@ -135,7 +146,8 @@ export function buildLanes(
       modelRoute: calendarConnectors.length > 0 ? 'agent_harness mode:"mcp_servers" query:"calendar"' : 'host action:"methods" query:"calendar"',
       signals: [
         `${calendarProviderRecords.length} fresh provider-backed calendar event record(s)`,
-        `${calendarMethods.length} calendar-like daemon method(s)`,
+        `${calendarMethods.length} dispatchable calendar-like daemon method(s)`,
+        ...(unavailableCalendarMethods.length > 0 ? [`${unavailableCalendarMethods.length} advertised-but-unavailable calendar method(s) (route not served by this daemon)`] : []),
         `${calendarConnectors.length} calendar-like MCP connector(s)`,
         `${calendarArtifactRecords.length} saved calendar review artifact(s)`,
         `${calendarReviewQueueRecords.length} saved calendar event queue item(s)`,
@@ -145,7 +157,7 @@ export function buildLanes(
       ],
       methodIds: calendarMethods,
       connectorSignals: calendarConnectors,
-      workflows: calendarWorkflows(calendarMethods, calendarConnectors),
+      workflows: calendarWorkflows(calendarMethods, calendarConnectors, unavailableCalendarMethods),
       liveRecords: [
         ...calendarProviderRecords,
         ...calendarReviewQueueRecords,

package/src/tools/agent-harness-personal-ops-operations.ts

@@ -107,7 +107,7 @@ export function reminderOperationRecords(methodIds: readonly string[], deliveryC
     {
       id: 'reminder-create',
       label: 'Create confirmed reminder',
-      status: hasMethod(methodIds, 'schedules.create') ? deliveryConfigured ? 'ready' : 'attention' : 'needs-setup',
+      status: hasMethod(methodIds, 'automation.schedules.create') ? deliveryConfigured ? 'ready' : 'attention' : 'needs-setup',
       summary: deliveryConfigured
         ? 'Create one connected reminder schedule with real timing and a visible delivery path.'
         : 'Create one reminder only after confirming timing and delivery scope; no configured delivery target was detected.',
@@ -123,7 +123,7 @@ export function reminderOperationRecords(methodIds: readonly string[], deliveryC
     {
       id: 'autonomous-schedule-create',
       label: 'Create autonomous schedule',
-      status: hasMethod(methodIds, 'schedules.create') ? 'ready' : 'needs-setup',
+      status: hasMethod(methodIds, 'automation.schedules.create') ? 'ready' : 'needs-setup',
       summary: 'Create one visible autonomous schedule only when task, cadence, success criteria, and user request provenance are explicit.',
       userRoute: 'Agent Workspace -> Automation -> Create schedule',
       modelRoute: 'schedule action:"create" task:"..." successCriteria:"..." scheduleKind:"..." scheduleValue:"..." confirm:true explicitUserRequest:"..."',
@@ -134,7 +134,7 @@ export function reminderOperationRecords(methodIds: readonly string[], deliveryC
       confirmationRequired: true,
     },
   ];
-  if (hasMethod(methodIds, 'schedules.list')) {
+  if (hasMethod(methodIds, 'automation.schedules.list')) {
     records.push({
       id: 'schedule-list',
       label: 'List connected schedules',
@@ -161,7 +161,7 @@ export function reminderOperationRecords(methodIds: readonly string[], deliveryC
       confirmationRequired: true,
     });
   }
-  if (hasMethod(methodIds, 'schedules.run')) {
+  if (hasMethod(methodIds, 'automation.schedules.run')) {
     records.push({
       id: 'schedule-run-now',
       label: 'Run schedule now',
@@ -176,7 +176,7 @@ export function reminderOperationRecords(methodIds: readonly string[], deliveryC
       confirmationRequired: true,
     });
   }
-  if (hasMethod(methodIds, 'schedules.disable')) {
+  if (hasMethod(methodIds, 'automation.schedules.disable')) {
     records.push({
       id: 'schedule-pause',
       label: 'Pause connected schedule',
@@ -191,7 +191,7 @@ export function reminderOperationRecords(methodIds: readonly string[], deliveryC
       confirmationRequired: true,
     });
   }
-  if (hasMethod(methodIds, 'schedules.enable')) {
+  if (hasMethod(methodIds, 'automation.schedules.enable')) {
     records.push({
       id: 'schedule-resume',
       label: 'Resume connected schedule',
@@ -206,7 +206,7 @@ export function reminderOperationRecords(methodIds: readonly string[], deliveryC
       confirmationRequired: true,
     });
   }
-  if (hasMethod(methodIds, 'schedules.delete')) {
+  if (hasMethod(methodIds, 'automation.schedules.delete')) {
     records.push({
       id: 'schedule-delete',
       label: 'Delete connected schedule',

package/src/tools/agent-harness-personal-ops-types.ts

@@ -28,6 +28,12 @@ export interface OperatorContractMethod {
   readonly title?: string;
   readonly description?: string;
   readonly category?: string;
+  /**
+   * W4-A3 capability-advertisement honesty: false means the method is
+   * cataloged but NOT dispatchable (no route/handler serves it). Absent
+   * means invokable (older contracts predate the flag).
+   */
+  readonly invokable?: boolean;
   readonly http?: {
     readonly method?: string;
     readonly path?: string;