@pellux/goodvibes-agent 1.5.2 → 1.5.3

package/src/tools/agent-harness-learning-curator.ts

@@ -3,7 +3,7 @@ import { buildAgentWorkspaceRuntimeSnapshot } from '../input/agent-workspace-sna
 import type { AgentWorkspaceLocalLibraryItem } from '../input/agent-workspace-types.ts';
 import { previewHarnessText } from './agent-harness-text.ts';
 import { buildLearningCandidates, candidateSearchText } from './agent-harness-learning-curator-proposals.ts';
-import { clampScore, isReviewed, localRegistryRoute, missingRequirementCount, routeValue, scoresForItem } from './agent-harness-learning-curator-common.ts';
+import { clampScore, localRegistryRoute, missingRequirementCount, routeValue, scoresForItem } from './agent-harness-learning-curator-common.ts';
 import type { AgentHarnessLearningCuratorArgs, LearningCandidate, LearningCandidateResolution, LearningConsolidationBatchPlan, LearningPromptPlan, LocalLearningCandidateDomain } from './agent-harness-learning-curator-types.ts';
 export type { LearningCandidate, LearningCandidateResolution, LearningConsolidationDiff, LearningConsolidationFields, LearningConsolidationPlan } from './agent-harness-learning-curator-types.ts';
 
@@ -184,7 +184,7 @@ function promptRecordPriority(item: AgentWorkspaceLocalLibraryItem): number {
 }
 
 function isPromptEligibleRecord(domain: LocalLearningCandidateDomain, item: AgentWorkspaceLocalLibraryItem): boolean {
-  if (!isReviewed(item)) return false;
+  // Fully autonomous learning: review gate removed — records qualify without human review.
   if (domain === 'memory') return (item.confidence ?? 100) >= 70;
   if (domain === 'persona') return item.active === true;
   if (domain === 'skill' || domain === 'skill_bundle' || domain === 'routine') {
@@ -202,10 +202,10 @@ function promptRecordEntry(domain: LocalLearningCandidateDomain, item: AgentWork
     priority: promptRecordPriority(item),
     scores: scoresForItem(item),
     reason: domain === 'memory'
-      ? 'Reviewed high-confidence memory is eligible for prompt recall.'
+      ? 'High-confidence memory (confidence ≥ 70) is eligible for prompt recall.'
       : domain === 'persona'
-        ? 'Reviewed active persona is eligible for prompt personality context.'
-        : 'Reviewed, enabled, setup-ready behavior is eligible for prompt context.',
+        ? 'Active persona is eligible for prompt personality context.'
+        : 'Enabled, setup-ready behavior is eligible for prompt context.',
     inspectRoute: localRegistryRoute(domain, 'get', item.id),
     ...(includeParameters ? {
       reviewState: item.reviewState,
@@ -280,9 +280,9 @@ function learningPromptPlan(context: CommandContext, candidates: readonly Learni
     consolidationQueue: consolidationCandidates.slice(0, includeParameters ? 8 : 3).map((candidate) => promptPlanCandidate(candidate, includeParameters)),
     suppressed,
     orderingRules: [
-      'Prompt context stays limited to reviewed high-confidence memory and reviewed setup-ready enabled behavior.',
-      'Usefulness, freshness, source-quality, and risk scores drive review priority before durable context expands.',
-      'Low-confidence, stale, setup-blocked, unreviewed, blocked VIBE.md, and duplicate records stay suppressed until reviewed or repaired.',
+      'Prompt context is limited to high-confidence memory (confidence ≥ 70), active personas, and enabled setup-ready behavior.',
+      'Usefulness, freshness, source-quality, and risk scores drive promotion priority and determine which records guide the assistant.',
+      'Low-confidence, stale, setup-blocked, blocked VIBE.md, and duplicate records stay suppressed until their confidence or enabled/active state is repaired.',
       'Proposals from notes, completed work, completed research, and saved sessions require explicit create or promotion routes before they can guide the assistant.',
     ],
     routes: {
@@ -336,7 +336,7 @@ export function learningCuratorSummary(context: CommandContext, args: AgentHarne
     returned: Math.min(filtered.length, limit),
     total: all.length,
     nextActions: nextActions(all),
-    policy: 'Learning curator is read-only. Proposed memory and behavior changes use reviewed notes, completed work-plan items, completed research runs, saved sessions, VIBE.md personality health cards, duplicate consolidation, and existing confirmed capture routes; durable context still requires provenance, review, rollback via stale/delete routes, and explicit user intent for writes or promotion.',
+    policy: 'Learning curator is read-only. Proposed memory and behavior changes use notes, completed work-plan items, completed research runs, saved sessions, VIBE.md personality health cards, duplicate consolidation, and existing confirmed capture routes; durable context still requires provenance, rollback via stale/delete routes, and explicit user intent for writes or promotion.',
   };
 }
 

package/src/tools/agent-harness-mode-catalog.ts

@@ -100,6 +100,7 @@ export const HARNESS_MODE_DESCRIPTORS: readonly HarnessModeDescriptor[] = [
   { id: 'autonomy_queue_item', kind: 'inspect', family: 'personal-ops', summary: 'Inspect one autonomy card, live records, tails, and routes.', next: 'Prefer autonomy action:"item".', parameters: ['queueItemId', 'target', 'query'] },
   { id: 'learning_curator', kind: 'discover', family: 'personal-ops', summary: 'Rank memory, notes, personas, skills, routines review/proposals.', next: 'Prefer memory action:"curator"; use action:"candidate" for one card.', parameters: ['query', 'limit', 'includeParameters'] },
   { id: 'learning_candidate', kind: 'inspect', family: 'personal-ops', summary: 'Inspect one local-learning candidate and safe existing routes.', parameters: ['candidateId', 'target', 'query'] },
+  { id: 'learning_auto_promote', kind: 'effect', family: 'personal-ops', summary: 'Auto-promote ready-to-promote; consolidate duplicates autonomously.', next: 'Use memory action:"curator" to see eligible items, then invoke.', keywords: ['auto promote', 'autonomous promotion', 'consolidate duplicates', 'learning loop', 'auto learning'] },
   { id: 'research_briefing', kind: 'discover', family: 'research', summary: 'Show one next-action queue for research runs, sources, reports.', next: 'Use research action:"briefing".', keywords: ['deep research', 'research cockpit', 'research next actions', 'research queue', 'source review', 'report queue'], parameters: ['query', 'target', 'limit', 'includeParameters'] },
   { id: 'research_workflow', kind: 'discover', family: 'research', summary: 'Plan research routes across run, source, report, browser, Knowledge.', next: 'Use research action:"plan"; runner checks browser readiness only.', parameters: ['query', 'target', 'runId', 'includeParameters'] },
   { id: 'research_runs', kind: 'discover', family: 'research', summary: 'List deep-research runs, phase, log tails, and controls.', next: 'Use research_run for one run.', parameters: ['query', 'limit', 'includeParameters'] },
@@ -146,6 +147,21 @@ export const HARNESS_MODE_DESCRIPTORS: readonly HarnessModeDescriptor[] = [
   { id: 'daemon', kind: 'alias', family: 'connected-host', summary: 'GoodVibes daemon -> connected_host; mutations use confirmed methods.', next: 'Prefer host action:"capabilities".', aliases: ['connected_host'], parameters: ['includeParameters'] },
   { id: 'daemon_status', kind: 'alias', family: 'connected-host', summary: 'GoodVibes daemon status -> connected_host_status.', next: 'Prefer host action:"status".', aliases: ['connected_host_status'], parameters: ['includeParameters'] },
   { id: 'propose_skill_drafts', kind: 'effect', family: 'personal-ops', summary: 'Draft up to 3 skills from recent learning candidates for review.', requiresConfirmation: true, keywords: ['skill draft', 'propose skill', 'auto-propose', 'draft skills', 'learning draft'], parameters: ['confirm', 'explicitUserRequest'] },
+  { id: 'remote_snapshot', kind: 'inspect', family: 'remote', summary: 'Route for the remote execution snapshot.', next: 'Call agent_operator_method methodId:"remote.snapshot".', keywords: ['remote execution', 'remote peers', 'remote work', 'distributed execution', 'remote runner', 'pair requests', 'remote snapshot'], parameters: ['includeParameters'] },
+  { id: 'remote_peers', kind: 'inspect', family: 'remote', summary: 'Route to list connected remote peers.', next: 'Call agent_operator_method methodId:"remote.peers.list".', keywords: ['remote peers', 'connected peers', 'distributed execution', 'remote runner', 'peer list'], parameters: ['includeParameters'] },
+  { id: 'remote_work', kind: 'inspect', family: 'remote', summary: 'Route to list queued and leased remote work.', next: 'Call agent_operator_method methodId:"remote.work.list".', keywords: ['remote work', 'queued work', 'leased work', 'distributed execution', 'remote work items', 'work queue'], parameters: ['includeParameters'] },
+  { id: 'remote_pair_requests', kind: 'inspect', family: 'remote', summary: 'Route to list remote pair requests.', next: 'Call agent_operator_method methodId:"remote.pair.requests.list".', keywords: ['remote pairing', 'pair requests', 'pending pair', 'distributed execution', 'remote pair'], parameters: ['includeParameters'] },
+  { id: 'remote_pair_approve', kind: 'effect', family: 'remote', summary: 'Confirmed handoff to approve a remote pair request.', requiresConfirmation: true, next: 'Execute the returned modelRoute with agent_operator_method.', keywords: ['approve pair request', 'remote pairing', 'accept pair', 'distributed execution'], parameters: ['requestId', 'target', 'note', 'confirm', 'explicitUserRequest'] },
+  { id: 'remote_pair_reject', kind: 'effect', family: 'remote', summary: 'Confirmed handoff to reject a remote pair request.', requiresConfirmation: true, next: 'Execute the returned modelRoute with agent_operator_method.', keywords: ['reject pair request', 'remote pairing', 'deny pair', 'distributed execution'], parameters: ['requestId', 'target', 'note', 'confirm', 'explicitUserRequest'] },
+  { id: 'remote_peers_invoke', kind: 'effect', family: 'remote', summary: 'Confirmed handoff to invoke a command on a peer.', requiresConfirmation: true, next: 'Execute the returned modelRoute with agent_operator_method.', keywords: ['peer invoke', 'remote command', 'invoke peer', 'distributed execution', 'remote execution'], parameters: ['peerId', 'command', 'payload', 'target', 'confirm', 'explicitUserRequest'] },
+  { id: 'remote_work_cancel', kind: 'effect', family: 'remote', summary: 'Confirmed handoff to cancel a remote work item.', requiresConfirmation: true, next: 'Execute the returned modelRoute with agent_operator_method.', keywords: ['cancel work', 'remote work cancel', 'cancel remote work', 'distributed execution'], parameters: ['workId', 'target', 'reason', 'confirm', 'explicitUserRequest'] },
+  { id: 'unified_inbox', kind: 'inspect', family: 'comms', summary: 'Aggregated unified inbox: deliveries, messages, routes.', next: 'Call channel_triage first; inbox aggregates triage.', keywords: ['inbox', 'unified inbox', 'deliveries', 'surface messages', 'route bindings', 'channel inbox', 'message feed'], parameters: ['limit'] },
+  { id: 'channel_drafts', kind: 'discover', family: 'comms', summary: 'List or inspect channel message drafts.', next: 'Use draftId to inspect one draft.', keywords: ['draft', 'channel draft', 'message draft', 'saved draft', 'pending message'], parameters: ['draftId', 'draftStatus', 'target', 'query', 'limit'] },
+  { id: 'channel_draft_save', kind: 'effect', family: 'comms', summary: 'Save or update a channel message draft.', requiresConfirmation: true, next: 'After save, use channel_draft_send to deliver.', keywords: ['save draft', 'create draft', 'update draft', 'draft message', 'compose'], parameters: ['draftId', 'draftMessage', 'draftTitle', 'draftChannel', 'draftRoute', 'draftWebhook', 'draftLink', 'draftTags', 'confirm', 'explicitUserRequest'] },
+  { id: 'channel_draft_send', kind: 'effect', family: 'comms', summary: 'Queue a draft and send via confirmed delivery path.', requiresConfirmation: true, next: 'Sends via agent_channel_send delivery path.', keywords: ['send draft', 'deliver draft', 'queue draft', 'draft send', 'channel send draft'], parameters: ['draftId', 'target', 'confirm', 'explicitUserRequest'] },
+  { id: 'channel_routing', kind: 'discover', family: 'comms', summary: 'List or inspect channel-to-profile routing rules.', next: 'Use surfaceKind/routeId to inspect one route.', keywords: ['channel routing', 'profile routing', 'routing rules', 'channel profile', 'surface routing'], parameters: ['surfaceKind', 'draftRoute', 'target', 'query', 'limit'] },
+  { id: 'channel_routing_assign', kind: 'effect', family: 'comms', summary: 'Assign a channel surface to a profile route.', requiresConfirmation: true, next: 'Check channel_routing to see saved assignments.', keywords: ['assign channel', 'profile assign', 'routing assign', 'channel to profile', 'route assign'], parameters: ['surfaceKind', 'profileId', 'draftRoute', 'routeLabel', 'confirm', 'explicitUserRequest'] },
+  { id: 'channel_routing_remove', kind: 'effect', family: 'comms', summary: 'Remove a channel-to-profile routing assignment.', requiresConfirmation: true, next: 'Check channel_routing after removal.', keywords: ['remove routing', 'delete routing', 'routing remove', 'profile unassign', 'unassign channel'], parameters: ['draftRoute', 'target', 'confirm', 'explicitUserRequest'] },
 ] as const;
 
 function readString(value: unknown): string {

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

@@ -315,8 +315,9 @@ export function connectorToolCount(signals: readonly PersonalOpsConnectorSignal[
 }
 
 export function workflowStatus(methodIds: readonly string[], connectors: readonly PersonalOpsConnectorSignal[]): PersonalOpsWorkflowStatus {
-  if (methodIds.length > 0 || connectorReady(connectors)) return 'ready';
+  if (connectorReady(connectors)) return 'ready';
   if (connectors.length > 0) return 'attention';
+  if (methodIds.length > 0) return 'ready';
   return 'needs-setup';
 }
 

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

@@ -5,6 +5,7 @@ import { providerBackedQueueRecords } from './agent-harness-personal-ops-provide
 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';
 import type { McpToolRecord, McpToolSchema, PersonalOpsLane, PersonalOpsLiveRecord } from './agent-harness-personal-ops-types.ts';
+import { buildStyleReplyLaneAdditions } from '../agent/email/style-reply-lane.ts';
 
 export function buildLanes(
   context: CommandContext,
@@ -44,6 +45,8 @@ export function buildLanes(
     && routine.reviewState === 'reviewed'
     && (routine.missingRequirementCount ?? 0) === 0
   )).length;
+  const hasEmailCapability = emailMethods.length > 0 || emailConnectors.length > 0;
+  const styleReplyAdditions = buildStyleReplyLaneAdditions(hasEmailCapability);
 
   return [
     {
@@ -55,7 +58,7 @@ export function buildLanes(
       outcome: 'Triage inbound email or message inboxes, summarize threads, draft replies, and send only after confirmation.',
       current: inboxProviderRecords.length > 0
         ? 'Fresh provider-backed inbox thread records are published by the connected daemon or SDK read model; Personal Ops can triage current queue state without inventing sends, labels, or archive effects.'
-        : emailMethods.length > 0
+        : emailMethods.length > 0 && emailConnectors.length === 0 && inboxArtifactRecords.length === 0 && inboxEffectReceiptRecords.length === 0
         ? 'The daemon contract exposes email-like methods; Personal Ops workflow cards now guide inbox triage and draft boundaries around exact methods.'
         : emailConnectors.length > 0
           ? 'A configured MCP connector looks email-capable; Personal Ops workflow cards now guide inbox triage, schema-derived operation records, and draft boundaries around its exact tools.'
@@ -66,7 +69,7 @@ export function buildLanes(
         : '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.'
-        : emailMethods.length > 0
+        : emailMethods.length > 0 && emailConnectors.length === 0 && inboxArtifactRecords.length === 0 && inboxEffectReceiptRecords.length === 0
         ? 'Use the inbox workflow cards to inspect exact methods, read selected threads, summarize priorities, and keep send as a separate confirmation.'
         : emailConnectors.length > 0
           ? 'Use the inbox workflow cards and operation records to inspect matching MCP connector schemas, then route triage only through reviewed connector actions.'
@@ -89,13 +92,14 @@ export function buildLanes(
       ],
       methodIds: emailMethods,
       connectorSignals: emailConnectors,
-      workflows: inboxWorkflows(emailMethods, emailConnectors),
+      workflows: [...inboxWorkflows(emailMethods, emailConnectors), styleReplyAdditions.workflow],
       liveRecords: [
         ...inboxProviderRecords,
         ...inboxReviewQueueRecords,
         ...inboxArtifactRecords,
         ...inboxEffectReceiptRecords,
         ...connectorRecords(emailConnectors, 'Inbox', 'inbox'),
+        styleReplyAdditions.liveRecord,
       ],
     },
     {
@@ -107,7 +111,7 @@ export function buildLanes(
       outcome: 'Read agenda context, identify conflicts, prepare briefings, and create reminders for calendar-driven work.',
       current: calendarProviderRecords.length > 0
         ? 'Fresh provider-backed calendar event records are published by the connected daemon or SDK read model; Personal Ops can brief current agenda and conflict state without inventing event edits or RSVP effects.'
-        : calendarMethods.length > 0
+        : calendarMethods.length > 0 && calendarConnectors.length === 0 && calendarArtifactRecords.length === 0 && calendarEffectReceiptRecords.length === 0
         ? 'The daemon contract exposes calendar-like methods; Personal Ops workflow cards now guide agenda briefing and conflict-scan boundaries.'
         : calendarConnectors.length > 0
           ? 'A configured MCP connector looks calendar-capable; Personal Ops workflow cards now guide agenda briefing, schema-derived operation records, and conflict-scan boundaries around its exact tools.'
@@ -118,7 +122,7 @@ export function buildLanes(
         : '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.'
-        : calendarMethods.length > 0
+        : calendarMethods.length > 0 && calendarConnectors.length === 0 && calendarArtifactRecords.length === 0 && calendarEffectReceiptRecords.length === 0
         ? 'Use the calendar workflow cards to inspect exact methods, fetch a bounded agenda window, and propose reminders or follow-ups.'
         : calendarConnectors.length > 0
           ? 'Use the calendar workflow cards and operation records to inspect matching MCP connector schemas, then route agenda work only through reviewed connector actions.'

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

@@ -0,0 +1,220 @@
+import type { CommandContext } from '../input/command-registry.ts';
+import { previewHarnessText } from './agent-harness-text.ts';
+
+export interface AgentHarnessRemoteArgs {
+  readonly target?: unknown;
+  readonly query?: unknown;
+  readonly peerId?: unknown;
+  readonly requestId?: unknown;
+  readonly workId?: unknown;
+  readonly command?: unknown;
+  readonly payload?: unknown;
+  readonly note?: unknown;
+  readonly reason?: unknown;
+  readonly limit?: unknown;
+  readonly includeParameters?: unknown;
+}
+
+type RemoteReadSurface =
+  | 'remote_snapshot'
+  | 'remote_peers'
+  | 'remote_work'
+  | 'remote_pair_requests';
+
+type RemoteMutationSurface =
+  | 'remote_pair_approve'
+  | 'remote_pair_reject'
+  | 'remote_peers_invoke'
+  | 'remote_work_cancel';
+
+type RemoteSurface = RemoteReadSurface | RemoteMutationSurface;
+
+interface RemoteMethodHandoff {
+  readonly surface: RemoteSurface;
+  readonly methodId: string;
+  readonly route: string;
+  readonly effect: 'confirmed-connected-host-state';
+  readonly confirmationRequired: true;
+  readonly input: Record<string, unknown>;
+  readonly modelRoute: string;
+  readonly policy: string;
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readRecord(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' && !Array.isArray(value)
+    ? value as Record<string, unknown>
+    : {};
+}
+
+// ---------------------------------------------------------------------------
+// Catalog status (for summary mode inclusion)
+// ---------------------------------------------------------------------------
+
+export function remoteCatalogStatus(_context: CommandContext): Record<string, unknown> {
+  return {
+    modes: [
+      'remote_snapshot',
+      'remote_peers',
+      'remote_work',
+      'remote_pair_requests',
+      'remote_pair_approve',
+      'remote_pair_reject',
+      'remote_peers_invoke',
+      'remote_work_cancel',
+    ],
+    readModes: 4,
+    mutationModes: 4,
+    policy:
+      'Distributed remote execution surface. Read modes call remote.snapshot, remote.peers.list, remote.work.list, and remote.pair.requests.list via agent_operator_method. Mutation modes (approve/reject pair requests, invoke peer command, cancel work) require confirm:true and explicitUserRequest and return an agent_operator_method handoff.',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Read surfaces — return route descriptors; agent_operator_method executes them
+// ---------------------------------------------------------------------------
+
+export function remoteSnapshotSummary(_args: AgentHarnessRemoteArgs): Record<string, unknown> {
+  return {
+    surface: 'remote_snapshot',
+    methodId: 'remote.snapshot',
+    route: 'GET /api/remote',
+    effect: 'read-only-network',
+    confirmationRequired: false,
+    modelRoute: previewHarnessText('agent_operator_method methodId:"remote.snapshot" input:{}'),
+    description:
+      'Returns a distributed remote execution snapshot: connected peers, queued/leased work, and pair request counts.',
+    policy:
+      'Read-only. Call agent_operator_method methodId:"remote.snapshot" input:{} to fetch the live snapshot from the daemon.',
+  };
+}
+
+export function remotePeersSummary(_args: AgentHarnessRemoteArgs): Record<string, unknown> {
+  return {
+    surface: 'remote_peers',
+    methodId: 'remote.peers.list',
+    route: 'GET /api/remote/peers',
+    effect: 'read-only-network',
+    confirmationRequired: false,
+    modelRoute: previewHarnessText('agent_operator_method methodId:"remote.peers.list" input:{}'),
+    description: 'Lists connected and recently-disconnected remote peers.',
+    policy:
+      'Read-only. Call agent_operator_method methodId:"remote.peers.list" input:{} to fetch the live peer list.',
+  };
+}
+
+export function remoteWorkSummary(_args: AgentHarnessRemoteArgs): Record<string, unknown> {
+  return {
+    surface: 'remote_work',
+    methodId: 'remote.work.list',
+    route: 'GET /api/remote/work',
+    effect: 'read-only-network',
+    confirmationRequired: false,
+    modelRoute: previewHarnessText('agent_operator_method methodId:"remote.work.list" input:{}'),
+    description: 'Lists queued and leased remote work items.',
+    policy:
+      'Read-only. Call agent_operator_method methodId:"remote.work.list" input:{} to fetch queued and leased work.',
+  };
+}
+
+export function remotePairRequestsSummary(_args: AgentHarnessRemoteArgs): Record<string, unknown> {
+  return {
+    surface: 'remote_pair_requests',
+    methodId: 'remote.pair.requests.list',
+    route: 'GET /api/remote/pair/requests',
+    effect: 'read-only-network',
+    confirmationRequired: false,
+    modelRoute: previewHarnessText('agent_operator_method methodId:"remote.pair.requests.list" input:{}'),
+    description: 'Lists pending, approved, and rejected remote pairing requests.',
+    policy:
+      'Read-only. Call agent_operator_method methodId:"remote.pair.requests.list" input:{} to fetch the current pair request queue.',
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Mutation surfaces — confirmed, return agent_operator_method handoff objects
+// ---------------------------------------------------------------------------
+
+export function remotePairApproveHandoff(args: AgentHarnessRemoteArgs): RemoteMethodHandoff {
+  const requestId = readString(args.requestId || args.target);
+  const note = readString(args.note);
+  const input: Record<string, unknown> = { requestId };
+  if (note) input.note = note;
+  return {
+    surface: 'remote_pair_approve',
+    methodId: 'remote.pair.requests.approve',
+    route: 'POST /api/remote/pair/requests/{requestId}/approve',
+    effect: 'confirmed-connected-host-state',
+    confirmationRequired: true,
+    input,
+    modelRoute: previewHarnessText(
+      `agent_operator_method methodId:"remote.pair.requests.approve" input:${JSON.stringify(input)} confirm:true explicitUserRequest:"..."`,
+    ),
+    policy:
+      'Mutation. Approves a pending remote pair request by requestId. Route it through agent_operator_method with confirm:true and the user\'s explicit request.',
+  };
+}
+
+export function remotePairRejectHandoff(args: AgentHarnessRemoteArgs): RemoteMethodHandoff {
+  const requestId = readString(args.requestId || args.target);
+  const note = readString(args.note);
+  const input: Record<string, unknown> = { requestId };
+  if (note) input.note = note;
+  return {
+    surface: 'remote_pair_reject',
+    methodId: 'remote.pair.requests.reject',
+    route: 'POST /api/remote/pair/requests/{requestId}/reject',
+    effect: 'confirmed-connected-host-state',
+    confirmationRequired: true,
+    input,
+    modelRoute: previewHarnessText(
+      `agent_operator_method methodId:"remote.pair.requests.reject" input:${JSON.stringify(input)} confirm:true explicitUserRequest:"..."`,
+    ),
+    policy:
+      'Mutation. Rejects a pending remote pair request by requestId. Route it through agent_operator_method with confirm:true and the user\'s explicit request.',
+  };
+}
+
+export function remotePeersInvokeHandoff(args: AgentHarnessRemoteArgs): RemoteMethodHandoff {
+  const peerId = readString(args.peerId || args.target);
+  const command = readString(args.command);
+  const payload = readRecord(args.payload);
+  const input: Record<string, unknown> = { peerId, command };
+  if (Object.keys(payload).length > 0) input.payload = payload;
+  return {
+    surface: 'remote_peers_invoke',
+    methodId: 'remote.peers.invoke',
+    route: 'POST /api/remote/peers/{peerId}/invoke',
+    effect: 'confirmed-connected-host-state',
+    confirmationRequired: true,
+    input,
+    modelRoute: previewHarnessText(
+      `agent_operator_method methodId:"remote.peers.invoke" input:${JSON.stringify(input)} confirm:true explicitUserRequest:"..."`,
+    ),
+    policy:
+      'Mutation. Invokes a command on a connected remote peer. Requires peerId and command. Route through agent_operator_method with confirm:true and the user\'s explicit request.',
+  };
+}
+
+export function remoteWorkCancelHandoff(args: AgentHarnessRemoteArgs): RemoteMethodHandoff {
+  const workId = readString(args.workId || args.target);
+  const reason = readString(args.reason);
+  const input: Record<string, unknown> = { workId };
+  if (reason) input.reason = reason;
+  return {
+    surface: 'remote_work_cancel',
+    methodId: 'remote.work.cancel',
+    route: 'POST /api/remote/work/{workId}/cancel',
+    effect: 'confirmed-connected-host-state',
+    confirmationRequired: true,
+    input,
+    modelRoute: previewHarnessText(
+      `agent_operator_method methodId:"remote.work.cancel" input:${JSON.stringify(input)} confirm:true explicitUserRequest:"..."`,
+    ),
+    policy:
+      'Mutation. Cancels a queued or leased remote work item by workId. Route through agent_operator_method with confirm:true and the user\'s explicit request.',
+  };
+}

package/src/tools/agent-harness-setup-smoke.ts

@@ -65,10 +65,8 @@ export function installSmokePlan(
     {
       id: 'first-assistant-turn',
       label: 'First assistant turn responds',
-      status: modelReady ? 'user-run' : 'blocked',
-      evidence: modelReady
-        ? 'Ask the main assistant for a short ready response after model routing is selected.'
-        : 'A first assistant turn needs a provider/model route first.',
+      status: 'user-run',
+      evidence: 'Ask the main assistant for a short ready response once a provider/model route is selected.',
       route: 'Ask the assistant: "Say ready in one sentence and list the active model route."',
     },
   ];

package/src/tools/agent-harness-tool-schema.ts

@@ -15,7 +15,7 @@ export const AGENT_HARNESS_MODES = [
   'personal_ops_briefing', 'personal_ops', 'personal_ops_queue', 'personal_ops_intake', 'personal_ops_lane', 'run_personal_ops_read',
   'memory_posture', 'memory_provider', 'memory_refinement', 'run_memory_refinement',
   'autonomy_intake', 'autonomy_queue', 'autonomy_queue_item',
-  'learning_curator', 'learning_candidate',
+  'learning_curator', 'learning_candidate', 'learning_auto_promote',
   'research_briefing', 'research_workflow', 'research_runs', 'research_run',
   'research_queue', 'research_source',
   'document_ops', 'document_ops_lane',
@@ -33,6 +33,11 @@ export const AGENT_HARNESS_MODES = [
   'connected_host', 'connected_host_status', 'connected_host_capability',
   'daemon', 'daemon_status',
   'propose_skill_drafts',
+  'remote_snapshot', 'remote_peers', 'remote_work', 'remote_pair_requests',
+  'remote_pair_approve', 'remote_pair_reject', 'remote_peers_invoke', 'remote_work_cancel',
+  'unified_inbox',
+  'channel_drafts', 'channel_draft_save', 'channel_draft_send',
+  'channel_routing', 'channel_routing_assign', 'channel_routing_remove',
 ] as const;
 
 const BACKGROUND_PROCESS_ACTION_VALUES = [
@@ -344,4 +349,78 @@ export const AGENT_HARNESS_PARAMETER_PROPERTIES = {
     type: 'string',
     description: 'User request authorizing a confirmed harness effect.',
   },
+  peerId: {
+    type: 'string',
+    description: 'Remote peer id for remote_peers_invoke or remote_peers_disconnect.',
+  },
+  requestId: {
+    type: 'string',
+    description: 'Pair request id for remote_pair_approve or remote_pair_reject.',
+  },
+  workId: {
+    type: 'string',
+    description: 'Remote work item id for remote_work_cancel.',
+  },
+  payload: {
+    type: 'object',
+    description: 'Command payload for remote_peers_invoke.',
+  },
+  note: {
+    type: 'string',
+    description: 'Optional note for remote pair request approve/reject.',
+  },
+  reason: {
+    type: 'string',
+    description: 'Optional cancellation reason for remote_work_cancel.',
+  },
+  draftId: {
+    type: 'string',
+    description: 'Channel draft id for channel_drafts, channel_draft_send.',
+  },
+  draftStatus: {
+    type: 'string',
+    enum: ['draft', 'queued', 'sent', 'failed'],
+    description: 'Status filter for channel_drafts list.',
+  },
+  draftTitle: {
+    type: 'string',
+    description: 'Optional title for channel_draft_save.',
+  },
+  draftMessage: {
+    type: 'string',
+    description: 'Message body for channel_draft_save.',
+  },
+  draftChannel: {
+    type: 'string',
+    description: 'Channel target for channel_draft_save.',
+  },
+  draftRoute: {
+    type: 'string',
+    description: 'Route id for channel_draft_save or channel_routing_remove.',
+  },
+  draftWebhook: {
+    type: 'string',
+    description: 'Webhook URL for channel_draft_save.',
+  },
+  draftLink: {
+    type: 'string',
+    description: 'Link target for channel_draft_save.',
+  },
+  draftTags: {
+    type: 'array',
+    items: { type: 'string' },
+    description: 'Tags for channel_draft_save.',
+  },
+  surfaceKind: {
+    type: 'string',
+    description: 'Channel surface kind for channel_routing or channel_routing_assign.',
+  },
+  profileId: {
+    type: 'string',
+    description: 'Profile id for channel_routing_assign.',
+  },
+  routeLabel: {
+    type: 'string',
+    description: 'Optional label for channel_routing_assign.',
+  },
 } as const;

package/src/tools/agent-harness-tool-types.ts

@@ -74,6 +74,24 @@ export interface AgentHarnessToolArgs {
   readonly pane?: unknown;
   readonly confirm?: unknown;
   readonly explicitUserRequest?: unknown;
+  readonly peerId?: unknown;
+  readonly requestId?: unknown;
+  readonly workId?: unknown;
+  readonly payload?: unknown;
+  readonly note?: unknown;
+  readonly reason?: unknown;
+  readonly draftId?: unknown;
+  readonly draftStatus?: unknown;
+  readonly draftTitle?: unknown;
+  readonly draftMessage?: unknown;
+  readonly draftChannel?: unknown;
+  readonly draftRoute?: unknown;
+  readonly draftWebhook?: unknown;
+  readonly draftLink?: unknown;
+  readonly draftTags?: unknown;
+  readonly surfaceKind?: unknown;
+  readonly profileId?: unknown;
+  readonly routeLabel?: unknown;
 }
 
 export interface AgentHarnessToolDeps {

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

@@ -8,6 +8,7 @@ import { channelReadinessCatalogStatus, describeHarnessChannel, describeHarnessC
 import { blockedHarnessCliCommandTokens, describeHarnessCliCommand, listHarnessCliCommands, totalHarnessCliCommands } from './agent-harness-cli-metadata.ts';
 import { describeHarnessCommand, listHarnessCommands } from './agent-harness-command-catalog.ts';
 import { describeLearningCandidate, learningCuratorCatalogStatus, learningCuratorSummary } from './agent-harness-learning-curator.ts';
+import { runAutoPromoter } from './agent-harness-learning-auto-promote.ts';
 import { runSkillDraftProposer } from '../agent/skill-draft-runner.ts';
 import { AgentSkillRegistry } from '../agent/skill-registry.ts';
 import { delegationPostureCatalogStatus, delegationPostureSummary, describeHarnessDelegationRoute } from './agent-harness-delegation-posture.ts';
@@ -55,6 +56,8 @@ import { AGENT_WORKSPACE_CATEGORIES, allWorkspaceActions, buildWorkspaceEditorCo
 import { connectedHostSummary, describeConnectedHostCapability, settingsPolicySummary } from './agent-harness-metadata.ts';
 import { countHarnessSettings, formatHarnessError, listHarnessSettings, resetHarnessSetting, resolveHarnessSetting, setHarnessSetting } from '../agent/harness-control.ts';
 import { buildAssistantCockpitFromSummaries } from '../agent/assistant-cockpit.ts';
+import { remoteCatalogStatus, remotePairApproveHandoff, remotePairRejectHandoff, remotePairRequestsSummary, remotePeersInvokeHandoff, remotePeersSummary, remoteSnapshotSummary, remoteWorkCancelHandoff, remoteWorkSummary } from './agent-harness-remote.ts';
+import { channelDraftSaveHandoff, channelDraftSendHandoff, channelDraftsSummary, channelRoutingAssignHandoff, channelRoutingRemoveHandoff, channelRoutingSummary, unifiedInboxSummary } from './agent-harness-comms.ts';
 
 function isMode(value: unknown): value is AgentHarnessMode {
   return typeof value === 'string' && AGENT_HARNESS_MODES.includes(value as AgentHarnessMode);
@@ -200,6 +203,7 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           const releaseReadiness = releaseReadinessInventoryStatus();
           const operatorMethods = operatorMethodCatalogStatus();
           const servicePosture = servicePostureCatalogStatus();
+          const remote = remoteCatalogStatus(deps.commandContext);
           const connectedHost = connectedHostSummary(deps.commandContext, deps.toolRegistry, {
             includeParameters: args.includeParameters === true,
           });
@@ -260,6 +264,7 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
             releaseReadiness,
             operatorMethods,
             servicePosture,
+            remote,
             modeGuide: compactHarnessModeGuide(),
             ...(args.includeParameters === true ? { modelAccess: detailedHarnessModelAccessGuide() } : {}),
             settingsPolicy: settingsPolicySummary(),
@@ -487,6 +492,21 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
           return error(resolved.usage);
         }
         if (args.mode === 'learning_curator') return output(learningCuratorSummary(deps.commandContext, args));
+        if (args.mode === 'learning_auto_promote') {
+          const shellPaths = deps.commandContext.workspace?.shellPaths;
+          if (!shellPaths) return error('learning_auto_promote requires an active workspace.');
+          const memoryApi = deps.commandContext.clients?.agentKnowledgeApi?.memory;
+          if (!memoryApi) return error('learning_auto_promote requires an active memory registry.');
+          const skillRegistry = AgentSkillRegistry.fromShellPaths(shellPaths);
+          const result = await runAutoPromoter(deps.commandContext, skillRegistry, memoryApi);
+          return output({
+            ...result,
+            message: result.promoted > 0
+              ? `Promoted ${result.promoted} item(s); consolidated ${result.consolidated} duplicate(s).`
+              : 'No items eligible for autonomous promotion this pass.',
+            policy: 'Autonomous promotion. Skills are created via the skill-draft runner. Memory, persona, routine creates call registry directly. Consolidation runs the full merge-stale-delete pipeline. Secret scanning enforced by each registry create().',
+          });
+        }
         if (args.mode === 'learning_candidate') {
           const resolved = describeLearningCandidate(deps.commandContext, args);
           if (resolved.status === 'found') return output(resolved.candidate);
@@ -721,6 +741,47 @@ export function createAgentHarnessTool(deps: AgentHarnessToolDeps): Tool {
             policy: 'Drafted skills are disabled and require review before use. Enable them under Memory > Skills.',
           });
         }
+        if (args.mode === 'remote_snapshot') return output(remoteSnapshotSummary(args));
+        if (args.mode === 'remote_peers') return output(remotePeersSummary(args));
+        if (args.mode === 'remote_work') return output(remoteWorkSummary(args));
+        if (args.mode === 'remote_pair_requests') return output(remotePairRequestsSummary(args));
+        if (args.mode === 'remote_pair_approve') {
+          const confirmationError = requireConfirmedAction(args, 'Remote pair request approval');
+          if (confirmationError) return error(confirmationError);
+          return output(remotePairApproveHandoff(args));
+        }
+        if (args.mode === 'remote_pair_reject') {
+          const confirmationError = requireConfirmedAction(args, 'Remote pair request rejection');
+          if (confirmationError) return error(confirmationError);
+          return output(remotePairRejectHandoff(args));
+        }
+        if (args.mode === 'remote_peers_invoke') {
+          const confirmationError = requireConfirmedAction(args, 'Remote peer command invocation');
+          if (confirmationError) return error(confirmationError);
+          return output(remotePeersInvokeHandoff(args));
+        }
+        if (args.mode === 'remote_work_cancel') {
+          const confirmationError = requireConfirmedAction(args, 'Remote work cancellation');
+          if (confirmationError) return error(confirmationError);
+          return output(remoteWorkCancelHandoff(args));
+        }
+        if (args.mode === 'unified_inbox') return output(await unifiedInboxSummary(deps.commandContext, args));
+        if (args.mode === 'channel_drafts') return output(channelDraftsSummary(deps.commandContext, args));
+        if (args.mode === 'channel_draft_save') {
+          const result = channelDraftSaveHandoff(deps.commandContext, args); return typeof result === 'string' ? error(result) : output(result);
+        }
+        if (args.mode === 'channel_draft_send') {
+          const result = await channelDraftSendHandoff(deps.commandContext, args); return typeof result === 'string' ? error(result) : output(result);
+        }
+        if (args.mode === 'channel_routing') return output(channelRoutingSummary(deps.commandContext, args));
+        if (args.mode === 'channel_routing_assign') {
+          const result = channelRoutingAssignHandoff(deps.commandContext, args);
+          return typeof result === 'string' ? error(result) : output(result);
+        }
+        if (args.mode === 'channel_routing_remove') {
+          const result = channelRoutingRemoveHandoff(deps.commandContext, args);
+          return typeof result === 'string' ? error(result) : output(result);
+        }
         return error(`Unhandled agent_harness mode: ${args.mode}`);
       } catch (err) {
         return error(formatHarnessError(err));