@pellux/goodvibes-agent 1.2.0 → 1.3.0

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

@@ -0,0 +1,116 @@
+import { previewHarnessText } from './agent-harness-text.ts';
+import { readRecord, readString } from './agent-harness-model-routing-utils.ts';
+import { redactedPersonalOpsText } from './agent-harness-personal-ops-runner.ts';
+import type { PersonalOpsRecordCertification } from './agent-harness-personal-ops-types.ts';
+
+function firstString(record: Readonly<Record<string, unknown>>, keys: readonly string[]): string {
+  for (const key of keys) {
+    const value = readString(record[key]);
+    if (value) return value;
+  }
+  return '';
+}
+
+function readStringArray(value: unknown): readonly string[] {
+  if (Array.isArray(value)) {
+    return [...new Set(value.map((entry) => readString(entry)).filter(Boolean))].slice(0, 12);
+  }
+  const text = readString(value);
+  return text ? text.split(',').map((entry) => entry.trim()).filter(Boolean).slice(0, 12) : [];
+}
+
+function recordsForCertification(record: Readonly<Record<string, unknown>>): readonly Readonly<Record<string, unknown>>[] {
+  return [
+    record,
+    readRecord(record.schema),
+    readRecord(record.contract),
+    readRecord(record.receipt),
+    readRecord(record.publication),
+    readRecord(record.certification),
+  ];
+}
+
+function firstAcross(records: readonly Readonly<Record<string, unknown>>[], keys: readonly string[]): string {
+  for (const record of records) {
+    const value = firstString(record, keys);
+    if (value) return value;
+  }
+  return '';
+}
+
+function normalizeSchemaStatus(records: readonly Readonly<Record<string, unknown>>[]): PersonalOpsRecordCertification['schemaStatus'] {
+  const explicit = firstAcross(records, ['schemaStatus', 'receiptSchemaStatus', 'certificationStatus'])
+    .toLowerCase()
+    .replace(/[_\s]+/g, '-');
+  if (['certified', 'valid', 'verified', 'schema-certified'].includes(explicit)) return 'certified';
+  const schemaVersion = firstAcross(records, ['schemaVersion', 'receiptSchemaVersion', 'contractVersion']);
+  const publicationGuarantee = firstAcross(records, ['publicationGuarantee', 'hostPublicationGuarantee', 'providerPublicationGuarantee', 'personalOpsPublicationGuarantee']);
+  const provenance = firstAcross(records, ['methodId', 'sourceTool', 'actionId', 'publisher', 'publisherId']);
+  return schemaVersion && publicationGuarantee && provenance ? 'certified' : 'legacy';
+}
+
+function redactedPreview(value: string, limit = 180): string {
+  return previewHarnessText(redactedPersonalOpsText(value), limit);
+}
+
+function receiptIds(record: Readonly<Record<string, unknown>>, records: readonly Readonly<Record<string, unknown>>[]): readonly string[] {
+  const explicit = [
+    ...readStringArray(record.receiptIds),
+    ...readStringArray(record.effectReceiptIds),
+    ...readStringArray(record.providerReceiptIds),
+    firstAcross(records, ['receiptId', 'effectReceiptId', 'readReceiptId', 'syncReceiptId', 'operationReceiptId']),
+  ].filter(Boolean);
+  return [...new Set(explicit.map((entry) => redactedPreview(entry, 96)))].slice(0, 12);
+}
+
+function provenance(record: Readonly<Record<string, unknown>>, records: readonly Readonly<Record<string, unknown>>[], sourcePath: string): readonly string[] {
+  const values = [
+    ...readStringArray(record.provenance),
+    sourcePath ? `source ${sourcePath}` : '',
+    firstAcross(records, ['methodId']) ? `method ${firstAcross(records, ['methodId'])}` : '',
+    firstAcross(records, ['actionId']) ? `action ${firstAcross(records, ['actionId'])}` : '',
+    firstAcross(records, ['sourceTool']) ? `sourceTool ${firstAcross(records, ['sourceTool'])}` : '',
+  ];
+  return [...new Set(values.map((entry) => redactedPreview(entry, 180)).filter(Boolean))].slice(0, 8);
+}
+
+export function personalOpsRecordCertification(input: {
+  readonly record: Readonly<Record<string, unknown>>;
+  readonly sourcePath: string;
+  readonly durableId: string;
+  readonly recordKind: string;
+  readonly hasConfirmedEffectRoute?: boolean;
+  readonly requireReceipt?: boolean;
+}): PersonalOpsRecordCertification {
+  const records = recordsForCertification(input.record);
+  const schemaStatus = normalizeSchemaStatus(records);
+  const schemaVersion = firstAcross(records, ['schemaVersion', 'receiptSchemaVersion', 'contractVersion']);
+  const publicationGuarantee = firstAcross(records, ['publicationGuarantee', 'hostPublicationGuarantee', 'providerPublicationGuarantee', 'personalOpsPublicationGuarantee']);
+  const publisher = firstAcross(records, ['publisher', 'publisherId', 'daemonId', 'hostId']);
+  const ids = receiptIds(input.record, records);
+  const primaryReceiptId = ids[0] ?? '';
+  const receiptStatus = firstAcross(records, ['receiptStatus', 'receiptOutcome', 'operationStatus']);
+  const receiptRoute = firstAcross(records, ['receiptRoute', 'inspectReceiptRoute', 'artifactRoute']);
+  const proof = provenance(input.record, records, input.sourcePath);
+  const missingSignals = [
+    ...(schemaStatus === 'certified' ? [] : [`Certified ${input.recordKind} schema is not published.`]),
+    ...(input.durableId ? [] : [`Durable ${input.recordKind} id is not published.`]),
+    ...(publicationGuarantee ? [] : [`Provider-side ${input.recordKind} publication guarantee is not published.`]),
+    ...(publisher ? [] : [`Provider-side ${input.recordKind} publisher is not published.`]),
+    ...(input.hasConfirmedEffectRoute ? [] : [`Confirmed ${input.recordKind} follow-up route is not published.`]),
+    ...(input.requireReceipt && ids.length === 0 ? [`Confirmed ${input.recordKind} execution receipt id is not published.`] : []),
+  ];
+  return {
+    schemaStatus,
+    ...(schemaVersion ? { schemaVersion: redactedPreview(schemaVersion, 80) } : {}),
+    ...(publicationGuarantee ? { publicationGuarantee: redactedPreview(publicationGuarantee, 220) } : {}),
+    ...(publisher ? { publisher: redactedPreview(publisher, 80) } : {}),
+    ...(proof.length > 0 ? { provenance: proof } : {}),
+    ...(primaryReceiptId ? { receiptId: primaryReceiptId } : {}),
+    ...(receiptStatus ? { receiptStatus: redactedPreview(receiptStatus, 80) } : {}),
+    ...(receiptRoute ? { receiptRoute: redactedPreview(receiptRoute, 180) } : {}),
+    ...(ids.length > 0 ? { receiptIds: ids } : {}),
+    missingSignals,
+    policy: 'Personal Ops treats provider records and effect receipts as certified only when the host or SDK publishes schema, durable id, publication guarantee, publisher/provenance, and exact confirmed routes or receipt ids; otherwise the row stays visible but not release-certifying.',
+  };
+}

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

@@ -1,7 +1,9 @@
 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 { channelRecords, connectorRecords, localRecord, refreshableSavedRecordCount, reminderOperationRecords, routineReceiptRecord, savedReviewArtifactRecords, savedReviewQueueRecords, taskOperationRecords } from './agent-harness-personal-ops-records.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';
 import type { McpToolRecord, McpToolSchema, PersonalOpsLane, PersonalOpsLiveRecord } from './agent-harness-personal-ops-types.ts';
 
 export function buildLanes(
@@ -18,14 +20,22 @@ export function buildLanes(
   const schemasByQualifiedName = options.schemasByQualifiedName ?? new Map<string, McpToolSchema>();
   const emailConnectors = connectorSignalsMatching(context, ['email', 'mail', 'imap', 'smtp', 'gmail'], { lane: 'inbox', toolsByServer: toolsByName, schemasByQualifiedName });
   const calendarConnectors = connectorSignalsMatching(context, ['calendar', 'caldav', 'agenda'], { lane: 'calendar', toolsByServer: toolsByName, schemasByQualifiedName });
+  const inboxProviderRecords = providerBackedQueueRecords(context, 'inbox');
+  const calendarProviderRecords = providerBackedQueueRecords(context, 'calendar');
   const inboxArtifactRecords = savedReviewArtifactRecords(context, 'inbox', emailConnectors);
   const calendarArtifactRecords = savedReviewArtifactRecords(context, 'calendar', calendarConnectors);
   const inboxReviewQueueRecords = savedReviewQueueRecords(context, 'inbox', emailConnectors);
   const calendarReviewQueueRecords = savedReviewQueueRecords(context, 'calendar', calendarConnectors);
+  const inboxEffectReceiptRecords = savedProviderEffectReceiptRecords(context, 'inbox');
+  const calendarEffectReceiptRecords = savedProviderEffectReceiptRecords(context, 'calendar');
   const refreshableInboxQueueRecords = refreshableSavedRecordCount(inboxReviewQueueRecords);
   const refreshableCalendarQueueRecords = refreshableSavedRecordCount(calendarReviewQueueRecords);
   const taskMethods = methodIdsMatching(['task', 'work-plan', 'workplan']);
   const scheduleMethods = methodIdsMatching(['schedule', 'reminder']);
+  const taskProviderRecords = providerBackedTaskRecords(context);
+  const reminderProviderRecords = providerBackedReminderRecords(context);
+  const taskEffectReceiptRecords = savedProviderEffectReceiptRecords(context, 'tasks');
+  const reminderEffectReceiptRecords = savedProviderEffectReceiptRecords(context, 'reminders');
   const readyChannels = snapshot.channels.filter((channel) => channel.ready).length;
   const enabledChannels = snapshot.channels.filter((channel) => channel.enabled).length;
   const configuredTargets = snapshot.channels.filter((channel) => channel.defaultTarget === 'configured').length;
@@ -39,29 +49,41 @@ export function buildLanes(
     {
       id: 'inbox',
       label: 'Inbox',
-      status: emailMethods.length > 0 || emailConnectors.length > 0 || inboxArtifactRecords.length > 0 ? 'partial' : 'gap',
+      status: inboxProviderRecords.length > 0
+        ? 'ready'
+        : emailMethods.length > 0 || emailConnectors.length > 0 || inboxArtifactRecords.length > 0 || inboxEffectReceiptRecords.length > 0 ? 'partial' : 'gap',
       outcome: 'Triage inbound email or message inboxes, summarize threads, draft replies, and send only after confirmation.',
-      current: emailMethods.length > 0
+      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
         ? '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.'
           : inboxArtifactRecords.length > 0
             ? '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.'
         : 'No email/IMAP/SMTP methods are present in the current GoodVibes SDK operator contract.',
-      next: emailMethods.length > 0
+      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
         ? '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.'
           : inboxArtifactRecords.length > 0
             ? 'Use saved thread queue records for local draft review or recap, then repair an email connector before reading fresh inbox data or sending.'
+            : inboxEffectReceiptRecords.length > 0
+              ? 'Review saved inbox provider-effect receipts, then repair an email connector before reading fresh inbox data or sending another provider effect.'
         : 'Install or build an email connector/MCP/plugin, then expose triage and draft-reply actions here.',
       userRoute: 'Agent Workspace -> Personal Ops -> Channels or connector setup',
       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)`,
         `${emailConnectors.length} email-like MCP connector(s)`,
         `${inboxArtifactRecords.length} saved inbox review artifact(s)`,
         `${inboxReviewQueueRecords.length} saved inbox thread queue item(s)`,
+        `${inboxEffectReceiptRecords.length} saved inbox provider-effect receipt(s)`,
         `${refreshableInboxQueueRecords} refreshable saved inbox queue item(s)`,
         `${readyChannels}/${snapshot.channels.length} channel(s) ready for delivery`,
       ],
@@ -69,37 +91,51 @@ export function buildLanes(
       connectorSignals: emailConnectors,
       workflows: inboxWorkflows(emailMethods, emailConnectors),
       liveRecords: [
+        ...inboxProviderRecords,
         ...inboxReviewQueueRecords,
         ...inboxArtifactRecords,
+        ...inboxEffectReceiptRecords,
         ...connectorRecords(emailConnectors, 'Inbox', 'inbox'),
       ],
     },
     {
       id: 'calendar',
       label: 'Calendar',
-      status: calendarMethods.length > 0 || calendarConnectors.length > 0 || calendarArtifactRecords.length > 0 ? 'partial' : 'gap',
+      status: calendarProviderRecords.length > 0
+        ? 'ready'
+        : calendarMethods.length > 0 || calendarConnectors.length > 0 || calendarArtifactRecords.length > 0 || calendarEffectReceiptRecords.length > 0 ? 'partial' : 'gap',
       outcome: 'Read agenda context, identify conflicts, prepare briefings, and create reminders for calendar-driven work.',
-      current: calendarMethods.length > 0
+      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
         ? '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.'
           : calendarArtifactRecords.length > 0
             ? '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.'
         : 'No calendar/CalDAV/agenda methods are present in the current GoodVibes SDK operator contract.',
-      next: calendarMethods.length > 0
+      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
         ? '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.'
           : calendarArtifactRecords.length > 0
             ? 'Use saved event queue records for recap or reminder creation, then repair a calendar connector before reading fresh agenda data or editing events.'
+            : calendarEffectReceiptRecords.length > 0
+              ? 'Review saved calendar provider-effect receipts, then repair a calendar connector before reading fresh agenda data or editing events.'
         : 'Add a CalDAV/calendar connector and route agenda briefing, conflicts, and reminders through this lane.',
       userRoute: 'Agent Workspace -> Personal Ops -> Create reminder',
       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)`,
         `${calendarConnectors.length} calendar-like MCP connector(s)`,
         `${calendarArtifactRecords.length} saved calendar review artifact(s)`,
         `${calendarReviewQueueRecords.length} saved calendar event queue item(s)`,
+        `${calendarEffectReceiptRecords.length} saved calendar provider-effect receipt(s)`,
         `${refreshableCalendarQueueRecords} refreshable saved calendar queue item(s)`,
         `${scheduleMethods.length} schedule/reminder method(s) available for follow-up`,
       ],
@@ -107,8 +143,10 @@ export function buildLanes(
       connectorSignals: calendarConnectors,
       workflows: calendarWorkflows(calendarMethods, calendarConnectors),
       liveRecords: [
+        ...calendarProviderRecords,
         ...calendarReviewQueueRecords,
         ...calendarArtifactRecords,
+        ...calendarEffectReceiptRecords,
         ...connectorRecords(calendarConnectors, 'Calendar', 'calendar'),
       ],
     },
@@ -132,36 +170,64 @@ export function buildLanes(
     {
       id: 'tasks',
       label: 'Tasks',
-      status: taskMethods.length > 0 ? 'ready' : 'partial',
+      status: taskProviderRecords.length > 0 || taskMethods.length > 0 || taskEffectReceiptRecords.length > 0 ? 'ready' : 'partial',
       outcome: 'Track user-visible work items, inspect host task state, and update work plan status without hidden jobs.',
-      current: `Agent has work-plan actions and ${taskMethods.length} task/work-plan daemon method(s) in the SDK contract.`,
-      next: 'Use work plans for user-visible task tracking; inspect runtime host tasks separately before mutating anything.',
+      current: taskProviderRecords.length > 0
+        ? `Fresh provider-backed task records are published by the connected daemon or SDK read model; Agent can review ${taskProviderRecords.length} current external task record(s) before any provider update, completion, defer, or delete route.`
+        : taskEffectReceiptRecords.length > 0
+          ? 'Saved task provider-effect receipts are available for audit and follow-up; no fresh task provider record is currently ready.'
+        : `Agent has work-plan actions and ${taskMethods.length} task/work-plan daemon method(s) in the SDK contract.`,
+      next: taskProviderRecords.length > 0
+        ? 'Inspect one provider task record, then use only a published confirmed follow-up route for updates, completion, defer, archive, or delete.'
+        : taskEffectReceiptRecords.length > 0
+          ? 'Review saved task provider-effect receipts, then repair or refresh the task provider before another provider update.'
+        : 'Use work plans for user-visible task tracking; inspect runtime host tasks separately before mutating anything.',
       userRoute: 'Agent Workspace -> Personal Ops -> Add work item',
       modelRoute: 'agent_work_plan action:"create"',
       signals: [
+        `${taskProviderRecords.length} fresh provider-backed task record(s)`,
+        `${taskEffectReceiptRecords.length} saved task provider-effect receipt(s)`,
         `${taskMethods.length} task/work-plan daemon method(s)`,
         'Work plan add/show/status/delete actions are available',
       ],
       methodIds: taskMethods,
       workflows: taskWorkflows(taskMethods),
-      liveRecords: taskOperationRecords(taskMethods),
+      liveRecords: [
+        ...taskProviderRecords,
+        ...taskEffectReceiptRecords,
+        ...taskOperationRecords(taskMethods),
+      ],
     },
     {
       id: 'reminders',
       label: 'Reminders',
-      status: scheduleMethods.length > 0 ? 'ready' : 'partial',
+      status: reminderProviderRecords.length > 0 || scheduleMethods.length > 0 || reminderEffectReceiptRecords.length > 0 ? 'ready' : 'partial',
       outcome: 'Turn a user request into a visible reminder or autonomous schedule with delivery target and cancellation path.',
-      current: `Reminder and autonomous schedule creation are available through Agent tools; ${scheduleMethods.length} schedule/reminder daemon method(s) are discoverable.`,
-      next: 'Create one confirmed reminder or autonomous schedule with title, time, scope, delivery target, success criteria, and explicit user request.',
+      current: reminderProviderRecords.length > 0
+        ? `Fresh provider-backed reminder records are published by the connected daemon or SDK read model; Agent can review ${reminderProviderRecords.length} current reminder record(s) before any edit, snooze, complete, or delete route.`
+        : reminderEffectReceiptRecords.length > 0
+          ? 'Saved reminder provider-effect receipts are available for audit and follow-up; no fresh reminder provider record is currently ready.'
+        : `Reminder and autonomous schedule creation are available through Agent tools; ${scheduleMethods.length} schedule/reminder daemon method(s) are discoverable.`,
+      next: reminderProviderRecords.length > 0
+        ? 'Inspect one provider reminder record, then use only a published confirmed follow-up route for edits, snooze, completion, cancellation, or delete.'
+        : reminderEffectReceiptRecords.length > 0
+          ? 'Review saved reminder provider-effect receipts, then repair or refresh the reminder provider before another provider update.'
+        : 'Create one confirmed reminder or autonomous schedule with title, time, scope, delivery target, success criteria, and explicit user request.',
       userRoute: 'Agent Workspace -> Personal Ops -> Create reminder',
       modelRoute: 'schedule action:"remind|create"',
       signals: [
+        `${reminderProviderRecords.length} fresh provider-backed reminder record(s)`,
+        `${reminderEffectReceiptRecords.length} saved reminder provider-effect receipt(s)`,
         `${scheduleMethods.length} schedule/reminder daemon method(s)`,
         `${configuredTargets} configured delivery target(s)`,
       ],
       methodIds: scheduleMethods,
       workflows: reminderWorkflows(scheduleMethods, configuredTargets > 0 || readyChannels > 0),
-      liveRecords: reminderOperationRecords(scheduleMethods, configuredTargets > 0 || readyChannels > 0),
+      liveRecords: [
+        ...reminderProviderRecords,
+        ...reminderEffectReceiptRecords,
+        ...reminderOperationRecords(scheduleMethods, configuredTargets > 0 || readyChannels > 0),
+      ],
     },
     {
       id: 'routines',

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

@@ -0,0 +1,225 @@
+import { hasMethod } from './agent-harness-personal-ops-discovery.ts';
+import type { PersonalOpsLiveRecord } from './agent-harness-personal-ops-types.ts';
+
+export function taskOperationRecords(methodIds: readonly string[]): readonly PersonalOpsLiveRecord[] {
+  const records: PersonalOpsLiveRecord[] = [
+    {
+      id: 'workplan-list',
+      label: 'Review visible work plan',
+      status: 'ready',
+      summary: 'Read Agent-owned work-plan items before starting or switching multi-step work.',
+      userRoute: 'Agent Workspace -> Work -> Review work plan',
+      modelRoute: 'agent_work_plan action:"list"',
+      tags: ['work-plan', 'task-read'],
+      effect: 'read-only',
+      capability: 'task-read',
+    },
+    {
+      id: 'workplan-add',
+      label: 'Add visible work item',
+      status: 'ready',
+      summary: 'Create one local Agent work-plan item instead of hiding task state in chat.',
+      userRoute: 'Agent Workspace -> Personal Ops -> Add work item',
+      modelRoute: 'agent_work_plan action:"create" title:"..."',
+      tags: ['work-plan', 'task-write'],
+      effect: 'confirmed-effect',
+      capability: 'task-write',
+      requiredFields: ['title'],
+      optionalFields: ['detail', 'priority', 'status'],
+      confirmationRequired: false,
+    },
+    {
+      id: 'workplan-status',
+      label: 'Update work item status',
+      status: 'ready',
+      summary: 'Move one visible work item through pending, active, blocked, done, failed, or cancelled state.',
+      userRoute: 'Agent Workspace -> Work -> Update work item status',
+      modelRoute: 'agent_work_plan action:"set_status" id:"..." status:"..."',
+      tags: ['work-plan', 'task-write'],
+      effect: 'confirmed-effect',
+      capability: 'task-write',
+      requiredFields: ['id', 'status'],
+      confirmationRequired: false,
+    },
+  ];
+  if (hasMethod(methodIds, 'tasks.list')) {
+    records.push({
+      id: 'host-tasks-list',
+      label: 'List connected-host tasks',
+      status: 'ready',
+      summary: 'Inspect connected-host task state without creating, retrying, or mutating host tasks.',
+      userRoute: 'Agent Workspace -> Work -> Host tasks',
+      modelRoute: 'workspace action:"action" actionId:"tasks-list"',
+      tags: ['host-task', 'task-read'],
+      effect: 'read-only',
+      capability: 'host-task-read',
+    });
+  }
+  if (hasMethod(methodIds, 'tasks.get') || hasMethod(methodIds, 'tasks.status')) {
+    records.push({
+      id: 'host-task-inspect',
+      label: 'Inspect connected-host task',
+      status: 'ready',
+      summary: 'Inspect one exact connected-host task id and output before considering controls.',
+      userRoute: 'Agent Workspace -> Work -> Inspect host task',
+      modelRoute: 'workspace action:"action" actionId:"task-show"',
+      tags: ['host-task', 'task-read'],
+      effect: 'read-only',
+      capability: 'host-task-read',
+      requiredFields: ['taskId'],
+    });
+  }
+  if (hasMethod(methodIds, 'tasks.cancel')) {
+    records.push({
+      id: 'host-task-cancel',
+      label: 'Cancel connected-host task',
+      status: 'ready',
+      summary: 'Cancel one exact connected-host task id only when the user authorizes it.',
+      userRoute: 'Agent Workspace -> Work -> Host task controls',
+      modelRoute: 'agent_operator_method methodId:"tasks.cancel" input:{"taskId":"..."} confirm:true explicitUserRequest:"..."',
+      tags: ['host-task', 'task-write'],
+      effect: 'confirmed-effect',
+      capability: 'host-task-control',
+      requiredFields: ['taskId'],
+      confirmationRequired: true,
+    });
+  }
+  if (hasMethod(methodIds, 'tasks.retry')) {
+    records.push({
+      id: 'host-task-retry',
+      label: 'Retry connected-host task',
+      status: 'ready',
+      summary: 'Retry one failed or cancelled connected-host task id only after inspection.',
+      userRoute: 'Agent Workspace -> Work -> Host task controls',
+      modelRoute: 'agent_operator_method methodId:"tasks.retry" input:{"taskId":"..."} confirm:true explicitUserRequest:"..."',
+      tags: ['host-task', 'task-write'],
+      effect: 'confirmed-effect',
+      capability: 'host-task-control',
+      requiredFields: ['taskId'],
+      confirmationRequired: true,
+    });
+  }
+  return records;
+}
+
+export function reminderOperationRecords(methodIds: readonly string[], deliveryConfigured: boolean): readonly PersonalOpsLiveRecord[] {
+  const records: PersonalOpsLiveRecord[] = [
+    {
+      id: 'reminder-create',
+      label: 'Create confirmed reminder',
+      status: hasMethod(methodIds, '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.',
+      userRoute: 'Agent Workspace -> Personal Ops -> Create reminder',
+      modelRoute: 'schedule action:"remind" message:"..." scheduleKind:"..." scheduleValue:"..." confirm:true explicitUserRequest:"..."',
+      tags: ['reminder', 'schedule-write'],
+      effect: 'confirmed-effect',
+      capability: 'reminder-create',
+      requiredFields: ['title', 'scheduleKind', 'scheduleValue'],
+      optionalFields: ['deliveryTargetId', 'timezone', 'message'],
+      confirmationRequired: true,
+    },
+    {
+      id: 'autonomous-schedule-create',
+      label: 'Create autonomous schedule',
+      status: hasMethod(methodIds, '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:"..."',
+      tags: ['autonomy', 'schedule-write'],
+      effect: 'confirmed-effect',
+      capability: 'schedule-create',
+      requiredFields: ['task', 'successCriteria', 'scheduleKind', 'scheduleValue'],
+      confirmationRequired: true,
+    },
+  ];
+  if (hasMethod(methodIds, 'schedules.list')) {
+    records.push({
+      id: 'schedule-list',
+      label: 'List connected schedules',
+      status: 'ready',
+      summary: 'Inspect configured schedules and history before running or mutating one.',
+      userRoute: 'Agent Workspace -> Automation -> Schedules',
+      modelRoute: 'workspace action:"action" actionId:"schedule-list"',
+      tags: ['schedule', 'schedule-read'],
+      effect: 'read-only',
+      capability: 'schedule-read',
+    });
+    records.push({
+      id: 'schedule-edit',
+      label: 'Edit connected schedule',
+      status: 'ready',
+      summary: 'Preview and edit one exact connected schedule id with before/after diff context.',
+      userRoute: 'Agent Workspace -> Automation -> Edit schedule',
+      modelRoute: 'schedule action:"edit" scheduleId:"..." confirm:true explicitUserRequest:"..."',
+      tags: ['schedule', 'schedule-write'],
+      effect: 'confirmed-effect',
+      capability: 'schedule-control',
+      requiredFields: ['scheduleId'],
+      optionalFields: ['name', 'scheduleKind', 'scheduleValue', 'prompt'],
+      confirmationRequired: true,
+    });
+  }
+  if (hasMethod(methodIds, 'schedules.run')) {
+    records.push({
+      id: 'schedule-run-now',
+      label: 'Run schedule now',
+      status: 'ready',
+      summary: 'Run one exact connected schedule id now after the user confirms.',
+      userRoute: 'Agent Workspace -> Automation -> Run job now',
+      modelRoute: 'schedule action:"run" scheduleId:"..." confirm:true explicitUserRequest:"..."',
+      tags: ['schedule', 'schedule-write'],
+      effect: 'confirmed-effect',
+      capability: 'schedule-control',
+      requiredFields: ['scheduleId'],
+      confirmationRequired: true,
+    });
+  }
+  if (hasMethod(methodIds, 'schedules.disable')) {
+    records.push({
+      id: 'schedule-pause',
+      label: 'Pause connected schedule',
+      status: 'ready',
+      summary: 'Disable one exact connected schedule id after reviewing current state.',
+      userRoute: 'Agent Workspace -> Automation -> Schedule controls',
+      modelRoute: 'schedule action:"pause" scheduleId:"..." confirm:true explicitUserRequest:"..."',
+      tags: ['schedule', 'schedule-write'],
+      effect: 'confirmed-effect',
+      capability: 'schedule-control',
+      requiredFields: ['scheduleId'],
+      confirmationRequired: true,
+    });
+  }
+  if (hasMethod(methodIds, 'schedules.enable')) {
+    records.push({
+      id: 'schedule-resume',
+      label: 'Resume connected schedule',
+      status: 'ready',
+      summary: 'Enable one exact connected schedule id after reviewing current state.',
+      userRoute: 'Agent Workspace -> Automation -> Schedule controls',
+      modelRoute: 'schedule action:"resume" scheduleId:"..." confirm:true explicitUserRequest:"..."',
+      tags: ['schedule', 'schedule-write'],
+      effect: 'confirmed-effect',
+      capability: 'schedule-control',
+      requiredFields: ['scheduleId'],
+      confirmationRequired: true,
+    });
+  }
+  if (hasMethod(methodIds, 'schedules.delete')) {
+    records.push({
+      id: 'schedule-delete',
+      label: 'Delete connected schedule',
+      status: 'ready',
+      summary: 'Delete one exact connected schedule id only after explicit user confirmation.',
+      userRoute: 'Agent Workspace -> Automation -> Schedule controls',
+      modelRoute: 'schedule action:"delete" scheduleId:"..." confirm:true explicitUserRequest:"..."',
+      tags: ['schedule', 'schedule-write'],
+      effect: 'confirmed-effect',
+      capability: 'schedule-control',
+      requiredFields: ['scheduleId'],
+      confirmationRequired: true,
+    });
+  }
+  return records;
+}