@pellux/goodvibes-agent 0.1.117 → 1.0.1

package/src/tools/agent-reminder-schedule-tool.ts

@@ -0,0 +1,237 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import type { ShellPathService } from '@/runtime/index.ts';
+import {
+  buildReminderSchedulePreview,
+  createReminderSchedule,
+  parseReminderScheduleArgs,
+  resolveReminderConnectedHostConnection,
+  type ReminderScheduleResult,
+} from '../agent/reminder-schedule.ts';
+import {
+  formatReminderScheduleFailure,
+  formatReminderSchedulePreview,
+  formatReminderScheduleSuccess,
+} from '../agent/reminder-schedule-format.ts';
+import type { AgentConnectedHostConfigReader } from '../agent/routine-schedule-promotion.ts';
+
+type ReminderScheduleKind = 'at' | 'every' | 'cron';
+
+export interface AgentReminderScheduleToolArgs {
+  readonly message?: unknown;
+  readonly scheduleKind?: unknown;
+  readonly scheduleValue?: unknown;
+  readonly timezone?: unknown;
+  readonly name?: unknown;
+  readonly provider?: unknown;
+  readonly model?: unknown;
+  readonly deliveryChannel?: unknown;
+  readonly deliveryRoute?: unknown;
+  readonly deliveryWebhook?: unknown;
+  readonly deliveryLink?: unknown;
+  readonly disabled?: unknown;
+  readonly confirm?: unknown;
+  readonly explicitUserRequest?: unknown;
+}
+
+const SCHEDULE_KINDS: readonly ReminderScheduleKind[] = ['at', 'every', 'cron'];
+
+function isScheduleKind(value: unknown): value is ReminderScheduleKind {
+  return typeof value === 'string' && SCHEDULE_KINDS.includes(value as ReminderScheduleKind);
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readOptionalString(value: unknown): string | null {
+  const text = readString(value);
+  return text ? text : null;
+}
+
+function readBoolean(value: unknown): boolean {
+  return value === true || value === 'true' || value === 'yes';
+}
+
+function addOptionalArg(args: string[], flag: string, value: unknown): void {
+  const text = readOptionalString(value);
+  if (!text) return;
+  args.push(flag, text);
+}
+
+function scheduleFlag(kind: ReminderScheduleKind): string {
+  if (kind === 'cron') return '--cron';
+  if (kind === 'every') return '--every';
+  return '--at';
+}
+
+function buildReminderScheduleArgs(rawArgs: AgentReminderScheduleToolArgs): readonly string[] {
+  const message = readOptionalString(rawArgs.message);
+  const scheduleValue = readOptionalString(rawArgs.scheduleValue);
+  if (!message) throw new Error('message is required.');
+  if (!isScheduleKind(rawArgs.scheduleKind)) throw new Error('scheduleKind must be one of: at, every, cron.');
+  if (!scheduleValue) throw new Error('scheduleValue is required.');
+
+  const args = [
+    scheduleFlag(rawArgs.scheduleKind),
+    scheduleValue,
+    '--message',
+    message,
+  ];
+  addOptionalArg(args, '--timezone', rawArgs.timezone);
+  addOptionalArg(args, '--name', rawArgs.name);
+  addOptionalArg(args, '--provider', rawArgs.provider);
+  addOptionalArg(args, '--model', rawArgs.model);
+  addOptionalArg(args, '--delivery-channel', rawArgs.deliveryChannel);
+  addOptionalArg(args, '--delivery-route', rawArgs.deliveryRoute);
+  addOptionalArg(args, '--delivery-webhook', rawArgs.deliveryWebhook);
+  addOptionalArg(args, '--delivery-link', rawArgs.deliveryLink);
+  if (readBoolean(rawArgs.disabled)) args.push('--disabled');
+  if (readBoolean(rawArgs.confirm)) args.push('--yes');
+  return args;
+}
+
+function outputForResult(result: ReminderScheduleResult): { readonly success: boolean; readonly output?: string; readonly error?: string } {
+  if (result.ok) {
+    return {
+      success: true,
+      output: formatReminderScheduleSuccess(result),
+    };
+  }
+  return {
+    success: false,
+    error: formatReminderScheduleFailure(result),
+  };
+}
+
+function confirmationError(preview: ReturnType<typeof buildReminderSchedulePreview>): string {
+  return [
+    formatReminderSchedulePreview(preview),
+    '',
+    'Model tool confirmation required. Call this tool with confirm:true only when the user explicitly asked GoodVibes Agent to create this reminder or schedule.',
+    'Do not create reminders from vague suggestions, brainstorming, routine startup, or inferred follow-up work.',
+  ].join('\n');
+}
+
+export function createAgentReminderScheduleTool(
+  shellPaths: ShellPathService,
+  configManager: AgentConnectedHostConfigReader,
+): Tool {
+  return {
+    definition: {
+      name: 'agent_reminder_schedule',
+      description: [
+        'Create one connected GoodVibes Agent reminder schedule from the main conversation.',
+        'Use only when the user explicitly asks to be reminded or asks Agent to schedule a reminder.',
+        'This calls the public schedules.create route on the connected GoodVibes host; it does not manage connected-host hosting, create a local scheduler, create separate Agent jobs, use delegated review, or write to default knowledge or non-Agent knowledge segments.',
+        'Set confirm:true only for an explicit user request. Otherwise return the preview/confirmation error.',
+      ].join(' '),
+      parameters: {
+        type: 'object',
+        properties: {
+          message: {
+            type: 'string',
+            description: 'Reminder text to deliver when the schedule fires.',
+          },
+          scheduleKind: {
+            type: 'string',
+            enum: [...SCHEDULE_KINDS],
+            description: 'Schedule selector: at for one timestamp, every for an interval, cron for a cron expression.',
+          },
+          scheduleValue: {
+            type: 'string',
+            description: 'ISO timestamp, interval, or cron expression matching scheduleKind.',
+          },
+          timezone: {
+            type: 'string',
+            description: 'Optional IANA timezone for cron/at schedules.',
+          },
+          name: {
+            type: 'string',
+            description: 'Optional connected schedule display name.',
+          },
+          provider: {
+            type: 'string',
+            description: 'Optional provider row id for reminder execution.',
+          },
+          model: {
+            type: 'string',
+            description: 'Optional model id for reminder execution.',
+          },
+          deliveryChannel: {
+            type: 'string',
+            description: 'Optional delivery channel target: surfaceKind:routeId:label, for example slack:ops:Ops.',
+          },
+          deliveryRoute: {
+            type: 'string',
+            description: 'Optional connected route target: routeId:label.',
+          },
+          deliveryWebhook: {
+            type: 'string',
+            description: 'Optional http(s) webhook target.',
+          },
+          deliveryLink: {
+            type: 'string',
+            description: 'Optional link delivery target.',
+          },
+          disabled: {
+            type: 'boolean',
+            description: 'Create the schedule disabled.',
+          },
+          confirm: {
+            type: 'boolean',
+            description: 'Required true only when the user explicitly asked to create this reminder.',
+          },
+          explicitUserRequest: {
+            type: 'string',
+            description: 'Short quote or summary of the user request that authorized this reminder creation.',
+          },
+        },
+        required: ['message', 'scheduleKind', 'scheduleValue', 'confirm', 'explicitUserRequest'],
+        additionalProperties: false,
+      },
+      sideEffects: ['network', 'state'],
+    },
+    execute: async (rawArgs: unknown) => {
+      try {
+        const args = rawArgs as AgentReminderScheduleToolArgs;
+        const explicitUserRequest = readOptionalString(args.explicitUserRequest);
+        if (!explicitUserRequest) {
+          return {
+            success: false,
+            error: 'explicitUserRequest is required so reminder creation stays tied to a direct user request.',
+          };
+        }
+        const parsed = parseReminderScheduleArgs(buildReminderScheduleArgs(args));
+        if (parsed.errors.length > 0) {
+          return {
+            success: false,
+            error: parsed.errors.join('\n'),
+          };
+        }
+        const preview = buildReminderSchedulePreview(parsed);
+        if (!parsed.yes) {
+          return {
+            success: false,
+            error: confirmationError(preview),
+          };
+        }
+        const connection = resolveReminderConnectedHostConnection(configManager, shellPaths.homeDirectory);
+        return outputForResult(await createReminderSchedule(connection, preview));
+      } catch (error) {
+        return {
+          success: false,
+          error: error instanceof Error ? error.message : String(error),
+        };
+      }
+    },
+  };
+}
+
+export function registerAgentReminderScheduleTool(
+  registry: ToolRegistry,
+  shellPaths: ShellPathService,
+  configManager: AgentConnectedHostConfigReader,
+): void {
+  registry.register(createAgentReminderScheduleTool(shellPaths, configManager));
+}

package/src/tools/agent-tool-policy-guard.ts

@@ -122,13 +122,13 @@ const READ_ONLY_QUERY_TOOL_MODE_SET = new Set<string>(READ_ONLY_QUERY_TOOL_MODES
 const READ_ONLY_CONTROL_TOOL_MODE_SET = new Set<string>(READ_ONLY_CONTROL_TOOL_MODES);
 
 const LOCAL_AGENT_DENIAL = [
-  'GoodVibes Agent does not spawn local Engineer/Reviewer/Tester/Verifier roots or run local WRFC chains.',
+  'GoodVibes Agent does not create coding-role Agent jobs or run local delegated review chains.',
   'Keep ordinary assistant work serial in the main conversation.',
   'For explicit build/fix/review work, delegate one request to GoodVibes TUI through the public shared-session/build-delegation contract with the full original user ask.',
 ].join(' ');
 
 const LOCAL_CODING_TOOL_DENIAL = [
-  'GoodVibes Agent does not perform direct local file mutation, local WRFC workflow execution, or local execution-isolation work from the main conversation.',
+  'GoodVibes Agent does not perform direct local file mutation, local delegated review workflow execution, or local execution-isolation work from the main conversation.',
   'For explicit build/fix/review/code execution work, delegate one request to GoodVibes TUI through the public shared-session/build-delegation contract with the full original user ask.',
   'For durable Agent memory, skills, personas, routines, and knowledge, use the Agent-owned commands and isolated Agent Knowledge routes.',
 ].join(' ');
@@ -140,9 +140,9 @@ const BACKGROUND_EXEC_DENIAL = [
 ].join(' ');
 
 const REMOTE_MUTATION_DENIAL = [
-  'GoodVibes Agent only inspects remote runner pools, contracts, artifacts, and review summaries from the main conversation.',
+  'GoodVibes Agent only inspects remote build-host pools, contracts, artifacts, and review summaries from the main conversation.',
   'Remote pool creation, assignment, unassignment, and artifact import are disabled here.',
-  'Use explicit GoodVibes TUI delegation or a future Agent approval flow for remote execution changes.',
+  'Use explicit GoodVibes TUI delegation for build/fix/review execution changes.',
 ].join(' ');
 
 const CHANNEL_ACTION_DENIAL = [
@@ -207,8 +207,8 @@ export function installAgentToolPolicyGuard(registry: ToolRegistry, options: Age
         allowedModes: READ_ONLY_REMOTE_TOOL_MODES,
         modeSet: READ_ONLY_REMOTE_TOOL_MODE_SET,
         description: [
-          'Read-only remote runner inspection for GoodVibes Agent.',
-          'Pool creation, runner assignment, unassignment, and artifact import are disabled in the main conversation.',
+          'Read-only remote build-host inspection for GoodVibes Agent.',
+          'Pool creation, host assignment, unassignment, and artifact import are disabled in the main conversation.',
         ].join(' '),
         denial: REMOTE_MUTATION_DENIAL,
       });
@@ -614,7 +614,7 @@ function isPresent(value: unknown): boolean {
 function narrowAgentToolDefinitionForAgentPolicy(tool: Tool): void {
   tool.definition.description = [
     'Read-only local Agent inspection for GoodVibes Agent.',
-    'This product does not spawn local worker agents or run local WRFC chains.',
+    'This product does not create separate Agent jobs or run local delegated review chains.',
     'For build/fix/review work, delegate to GoodVibes TUI through the explicit build-delegation path instead.',
   ].join(' ');
   tool.definition.sideEffects = [];
@@ -624,7 +624,7 @@ function narrowAgentToolDefinitionForAgentPolicy(tool: Tool): void {
   const modeProperty = properties.mode;
   if (!isRecord(modeProperty)) return;
   modeProperty.enum = [...READ_ONLY_AGENT_TOOL_MODES];
-  modeProperty.description = 'Read-only Agent inspection mode. Local spawn, batch-spawn, cancel, message, wait, and plan modes are disabled in GoodVibes Agent.';
+  modeProperty.description = 'Read-only Agent inspection mode. Separate Agent job creation, batch creation, cancel, message, wait, and plan modes are disabled in GoodVibes Agent.';
 }
 
 function narrowExecToolDefinitionForAgentPolicy(tool: Tool): void {

package/src/tools/agent-work-plan-tool.ts

@@ -0,0 +1,256 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import {
+  WORK_PLAN_STATUSES,
+  type WorkPlanItem,
+  type WorkPlanItemStatus,
+  type WorkPlanStore,
+} from '../work-plans/work-plan-store.ts';
+
+export type AgentWorkPlanAction =
+  | 'list'
+  | 'get'
+  | 'create'
+  | 'update'
+  | 'set_status'
+  | 'remove'
+  | 'clear_completed';
+
+export interface AgentWorkPlanToolArgs {
+  readonly action?: unknown;
+  readonly id?: unknown;
+  readonly title?: unknown;
+  readonly status?: unknown;
+  readonly owner?: unknown;
+  readonly source?: unknown;
+  readonly notes?: unknown;
+  readonly confirm?: unknown;
+  readonly explicitUserRequest?: unknown;
+}
+
+const ACTIONS: readonly AgentWorkPlanAction[] = [
+  'list',
+  'get',
+  'create',
+  'update',
+  'set_status',
+  'remove',
+  'clear_completed',
+];
+
+function isAction(value: unknown): value is AgentWorkPlanAction {
+  return typeof value === 'string' && ACTIONS.includes(value as AgentWorkPlanAction);
+}
+
+function isStatus(value: unknown): value is WorkPlanItemStatus {
+  return typeof value === 'string' && WORK_PLAN_STATUSES.includes(value as WorkPlanItemStatus);
+}
+
+function readString(value: unknown): string {
+  return typeof value === 'string' ? value.trim() : '';
+}
+
+function readBoolean(value: unknown): boolean {
+  return value === true || value === 'true' || value === 'yes';
+}
+
+function failure(error: string): { readonly success: false; readonly error: string } {
+  return { success: false, error };
+}
+
+function output(text: string): { readonly success: true; readonly output: string } {
+  return { success: true, output: text };
+}
+
+function requireId(args: AgentWorkPlanToolArgs): string {
+  const id = readString(args.id);
+  if (!id) throw new Error('id is required.');
+  return id;
+}
+
+function requireTitle(args: AgentWorkPlanToolArgs): string {
+  const title = readString(args.title);
+  if (!title) throw new Error('title is required.');
+  return title;
+}
+
+function readOptionalStatus(value: unknown): WorkPlanItemStatus | undefined {
+  if (value === undefined || value === null || readString(value) === '') return undefined;
+  if (!isStatus(value)) throw new Error(`Invalid status. Valid values ${WORK_PLAN_STATUSES.join(', ')}.`);
+  return value;
+}
+
+function formatStatus(status: WorkPlanItemStatus): string {
+  return status.replace(/_/g, ' ');
+}
+
+function formatItem(item: WorkPlanItem): string {
+  const owner = item.owner ? ` owner ${item.owner}` : '';
+  const source = item.source ? ` source=${item.source}` : '';
+  const completed = item.completedAt ? ` completed ${new Date(item.completedAt).toISOString()}` : '';
+  return `${item.id}  ${formatStatus(item.status)}${owner}${source}${completed}  ${item.title}`;
+}
+
+function formatItemDetail(item: WorkPlanItem): string {
+  return [
+    formatItem(item),
+    `created ${new Date(item.createdAt).toISOString()}`,
+    `updated ${new Date(item.updatedAt).toISOString()}`,
+    item.linked
+      ? `linked ${Object.entries(item.linked).map(([key, value]) => `${key} ${String(value)}`).join(', ')}`
+      : 'linked (none)',
+    '',
+    item.notes || '(no notes)',
+  ].join('\n');
+}
+
+function resolveItem(store: WorkPlanStore, idOrPrefix: string): WorkPlanItem {
+  const needle = idOrPrefix.trim();
+  if (!needle) throw new Error('id is required.');
+  const items = store.listItems();
+  const exact = items.find((item) => item.id === needle);
+  if (exact) return exact;
+  const matches = items.filter((item) => item.id.startsWith(needle));
+  if (matches.length === 1) return matches[0]!;
+  if (matches.length > 1) {
+    throw new Error(`Work plan item id "${needle}" is ambiguous. Matches ${matches.map((item) => item.id).join(', ')}`);
+  }
+  throw new Error(`Work plan item not found ${needle}`);
+}
+
+function listOutput(store: WorkPlanStore): string {
+  const plan = store.getActivePlan();
+  const counts = new Map<WorkPlanItemStatus, number>(WORK_PLAN_STATUSES.map((status) => [status, 0]));
+  for (const item of plan.items) counts.set(item.status, (counts.get(item.status) ?? 0) + 1);
+  const lines = [
+    'Agent local work plan',
+    `  plan ${plan.id}`,
+    `  project ${plan.projectRoot}`,
+    `  items ${plan.items.length}; pending ${counts.get('pending') ?? 0}; active ${counts.get('in_progress') ?? 0}; blocked ${counts.get('blocked') ?? 0}; done ${counts.get('done') ?? 0}`,
+  ];
+  if (plan.items.length === 0) {
+    lines.push('', 'No local work plan items.');
+    return lines.join('\n');
+  }
+  lines.push('', ...plan.items.slice(0, 20).map(formatItem));
+  if (plan.items.length > 20) lines.push(`${plan.items.length - 20} more item(s) omitted.`);
+  return lines.join('\n');
+}
+
+function requireDestructiveConfirmation(args: AgentWorkPlanToolArgs, action: string): string | null {
+  const explicitUserRequest = readString(args.explicitUserRequest);
+  if (!explicitUserRequest) return `explicitUserRequest is required before ${action}.`;
+  if (!readBoolean(args.confirm)) {
+    return [
+      `Agent work plan ${action} preview`,
+      '  policy destructive local work-plan changes require confirm:true and an explicit user request',
+      `  request ${explicitUserRequest}`,
+    ].join('\n');
+  }
+  return null;
+}
+
+function updatePatch(args: AgentWorkPlanToolArgs): Parameters<WorkPlanStore['updateItem']>[1] {
+  const status = readOptionalStatus(args.status);
+  return {
+    ...(args.title !== undefined ? { title: requireTitle(args) } : {}),
+    ...(status !== undefined ? { status } : {}),
+    ...(args.owner !== undefined ? { owner: readString(args.owner) || null } : {}),
+    ...(args.source !== undefined ? { source: readString(args.source) || null } : {}),
+    ...(args.notes !== undefined ? { notes: readString(args.notes) || null } : {}),
+  };
+}
+
+export function createAgentWorkPlanTool(store: WorkPlanStore): Tool {
+  return {
+    definition: {
+      name: 'agent_work_plan',
+      description: [
+        'Inspect and maintain the visible GoodVibes Agent local work plan from the main conversation.',
+        'Use this to track concrete tasks the assistant is doing or has agreed to do, so the work is visible in the Agent TUI workspace.',
+        'This uses only Agent-local persisted work-plan state; it does not call connected-host mutation routes, start background jobs, create separate Agent jobs, use delegated review, write default knowledge, or use non-Agent knowledge segments.',
+        'Create, update, and set_status are safe local state actions. remove and clear_completed require confirm:true plus explicitUserRequest.',
+      ].join(' '),
+      parameters: {
+        type: 'object',
+        properties: {
+          action: { type: 'string', enum: [...ACTIONS] },
+          id: { type: 'string', description: 'Work plan item id or unique id prefix for get/update/set_status/remove.' },
+          title: { type: 'string', description: 'Work plan item title for create/update.' },
+          status: { type: 'string', enum: [...WORK_PLAN_STATUSES], description: 'Work plan item status.' },
+          owner: { type: 'string', description: 'Optional owner label.' },
+          source: { type: 'string', description: 'Optional source/provenance label.' },
+          notes: { type: 'string', description: 'Optional work-plan notes.' },
+          confirm: { type: 'boolean', description: 'Required true for remove and clear_completed.' },
+          explicitUserRequest: { type: 'string', description: 'Required for destructive remove and clear_completed actions.' },
+        },
+        required: ['action'],
+        additionalProperties: false,
+      },
+      sideEffects: ['state'],
+    },
+    execute: async (rawArgs: unknown) => {
+      try {
+        const args = rawArgs as AgentWorkPlanToolArgs;
+        if (!isAction(args.action)) return failure(`Unknown Agent work plan action. Valid values ${ACTIONS.join(', ')}.`);
+        if (args.action === 'list') return output(listOutput(store));
+        if (args.action === 'get') return output(formatItemDetail(resolveItem(store, requireId(args))));
+        if (args.action === 'create') {
+          const item = store.addItem(requireTitle(args), {
+            status: readOptionalStatus(args.status) ?? 'pending',
+            owner: readString(args.owner) || 'agent',
+            source: readString(args.source) || 'main-conversation',
+            notes: readString(args.notes) || undefined,
+          });
+          return output([
+            'Created Agent work plan item',
+            `  id ${item.id}`,
+            `  title ${item.title}`,
+          ].join('\n'));
+        }
+        if (args.action === 'update') {
+          const item = store.updateItem(requireId(args), updatePatch(args));
+          return output([
+            'Updated Agent work plan item',
+            `  id ${item.id}`,
+            `  title ${item.title}`,
+          ].join('\n'));
+        }
+        if (args.action === 'set_status') {
+          const status = readOptionalStatus(args.status);
+          if (!status) throw new Error('status is required.');
+          const item = store.setItemStatus(requireId(args), status);
+          return output([
+            'Set Agent work plan item status',
+            `  id ${item.id}`,
+            `  status ${formatStatus(item.status)}`,
+            `  title ${item.title}`,
+          ].join('\n'));
+        }
+        if (args.action === 'remove') {
+          const denied = requireDestructiveConfirmation(args, `remove ${readString(args.id) || '(missing id)'}`);
+          if (denied) return failure(denied);
+          const item = store.removeItem(requireId(args));
+          return output([
+            'Removed Agent work plan item',
+            `  id ${item.id}`,
+            `  title ${item.title}`,
+          ].join('\n'));
+        }
+        const denied = requireDestructiveConfirmation(args, 'clear completed');
+        if (denied) return failure(denied);
+        const count = store.clearCompleted();
+        return output([
+          `Cleared ${count} completed/cancelled Agent work plan items`,
+          `  count ${count}`,
+        ].join('\n'));
+      } catch (error) {
+        return failure(error instanceof Error ? error.message : String(error));
+      }
+    },
+  };
+}
+
+export function registerAgentWorkPlanTool(registry: ToolRegistry, store: WorkPlanStore): void {
+  registry.register(createAgentWorkPlanTool(store));
+}

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.117';
+let _version = '1.0.1';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {