@pellux/goodvibes-agent 0.1.105 → 0.1.107

package/src/input/onboarding/onboarding-wizard-steps.ts

@@ -1,9 +1,10 @@
 import { REASONING_OPTIONS, HITL_MODE_OPTIONS, GUIDANCE_MODE_OPTIONS, PERMISSION_MODE_OPTIONS, SECRET_POLICY_OPTIONS } from './onboarding-wizard-constants.ts';
 import { modelSelectionLabel, normalizeText } from './onboarding-wizard-helpers.ts';
+import { buildAgentKnowledgeStep, buildAutomationStep, buildCommunicationStep, buildDelegationPolicyStep, buildLocalStateStep, buildToolsStep, buildVoiceMediaStep } from './onboarding-wizard-operator-steps.ts';
 import { listAgentRuntimeProfileTemplates } from '../../agent/runtime-profile.ts';
 import type { OnboardingWizardController } from './onboarding-wizard.ts';
 import type { OnboardingWizardActionFieldDefinition, OnboardingWizardFieldDefinition, OnboardingWizardModelPickerFieldDefinition, OnboardingWizardRadioFieldDefinition, OnboardingWizardRadioOption, OnboardingWizardStepDefinition } from './onboarding-wizard-types.ts';
-import type { OnboardingStep1CapabilityId, OnboardingStep1CapabilityItem } from '../../runtime/onboarding/index.ts';
+import type { OnboardingProviderAccountRecord, OnboardingStep1CapabilityId, OnboardingStep1CapabilityItem } from '../../runtime/onboarding/index.ts';
 
 function buildStarterTemplateOptions(): readonly OnboardingWizardRadioOption[] {
   return [
@@ -82,6 +83,27 @@ function profileSetupLabel(controller: OnboardingWizardController): string {
   return templateId === 'none' ? `Create ${profileName}` : `Create ${profileName} from ${templateId}`;
 }
 
+function formatBoundedList(values: readonly string[], empty: string): string {
+  const unique = [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))]
+    .sort((left, right) => left.localeCompare(right));
+  if (unique.length === 0) return empty;
+  if (unique.length <= 4) return unique.join(', ');
+  return `${unique.slice(0, 4).join(', ')} +${unique.length - 4} more`;
+}
+
+function providerAccountLabel(provider: OnboardingProviderAccountRecord): string {
+  const route = provider.activeRoute && provider.activeRoute !== 'unconfigured'
+    ? provider.activeRoute
+    : provider.oauthReady
+      ? 'oauth-ready'
+      : provider.pendingLogin
+        ? 'pending-login'
+        : provider.configured
+          ? 'configured'
+          : 'unconfigured';
+  return `${provider.providerId}:${route}`;
+}
+
 function buildReviewReadinessFields(controller: OnboardingWizardController): readonly OnboardingWizardFieldDefinition[] {
   const localBehavior = findRuntimeCapability(controller, 'local-behavior');
   const channels = findRuntimeCapability(controller, 'communication-channels');
@@ -151,96 +173,6 @@ function buildReviewReadinessFields(controller: OnboardingWizardController): rea
   ];
 }
 
-export function buildCommunicationStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-communication',
-    title: 'Channels and notifications',
-    shortLabel: 'Channels',
-    description: 'Prepare the Agent for companion pairing, messaging-channel awareness, notification delivery, and safe outbound communication while leaving runtime hosting external.',
-    summaryTitle: 'Communication posture',
-    summaryLines: [
-      'Companion chat: paired through the GoodVibes runtime',
-      'Channel accounts: inspect readiness before using them',
-      'Outbound messages: explicit user action only',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-communication.companion',
-        label: 'Companion pairing',
-        hint: 'Use /pair from the Agent workspace to pair companion clients through the already-running GoodVibes runtime.',
-        defaultValue: 'External runtime route',
-      },
-      {
-        kind: 'status',
-        id: 'agent-communication.channels',
-        label: 'Messaging channels',
-        hint: 'Use the Channels workspace to inspect account readiness, delivery posture, and recent communication without changing runtime hosting.',
-        defaultValue: 'Inspectable',
-      },
-      {
-        kind: 'status',
-        id: 'agent-communication.notifications',
-        label: 'Notification delivery',
-        hint: 'Routine, approval, and work-plan notifications require an explicit delivery target and command; Agent never silently sends external messages.',
-        defaultValue: 'Explicit only',
-      },
-      {
-        kind: 'status',
-        id: 'agent-communication.inbound-policy',
-        label: 'Inbound command policy',
-        hint: 'Incoming channel commands stay constrained by runtime policy, allowlists, and account posture.',
-        defaultValue: 'Policy gated',
-      },
-    ],
-  };
-}
-
-export function buildToolsStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-tools',
-    title: 'Tools and MCP',
-    shortLabel: 'Tools',
-    description: 'Review tool access for the Agent operator: MCP servers, browser/media helpers, safe read-only inspection, and explicit approval before side effects.',
-    summaryTitle: 'Tool posture',
-    summaryLines: [
-      'MCP and tools: inspect before use',
-      'Read/search/summarize: safe by default',
-      'Writes, installs, external sends, and account changes: require explicit user action',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-tools.mcp',
-        label: 'MCP servers and tools',
-        hint: 'Use /mcp servers and the Agent workspace Tools area to inspect connected servers, roles, and tool readiness.',
-        defaultValue: 'Inspectable',
-      },
-      {
-        kind: 'status',
-        id: 'agent-tools.browser-media',
-        label: 'Browser and media helpers',
-        hint: 'Browser, image, audio, and file helpers are task-scoped tools. Agent uses them only when the current task needs them and policy allows it.',
-        defaultValue: 'Task scoped',
-      },
-      {
-        kind: 'status',
-        id: 'agent-tools.approval-boundary',
-        label: 'Power action boundary',
-        hint: 'Workspace writes, package installs, external sends, and account changes require an explicit command or confirmation.',
-        defaultValue: 'Approval required',
-      },
-      {
-        kind: 'status',
-        id: 'agent-tools.no-hidden-work',
-        label: 'Hidden work policy',
-        hint: 'Tool use stays visible in the main Agent conversation or explicit command workspace; no hidden background work is started from onboarding.',
-        defaultValue: 'Visible',
-      },
-    ],
-  };
-}
-
 export function buildLoadingStep(controller: OnboardingWizardController): OnboardingWizardStepDefinition {
   const failed = controller.hydrationError !== null;
   return {
@@ -342,17 +274,42 @@ export function buildProviderAccessStep(controller: OnboardingWizardController):
   const openAiPending = pendingSubscriptions.some((subscription) => subscription.provider === 'openai');
   const providerSecretCount = controller.runtimeSnapshot?.secrets.records.filter((record) => record.key.endsWith('_API_KEY') || record.key.endsWith('_TOKEN')).length ?? 0;
   const openAiApiKeyConfigured = controller.runtimeSnapshot?.secrets.records.some((record) => record.key === 'OPENAI_API_KEY') ?? false;
+  const routing = controller.runtimeSnapshot?.providerRouting;
+  const accountProviders = controller.runtimeSnapshot?.providerAccounts?.providers ?? [];
+  const configuredAccounts = accountProviders.filter((provider) =>
+    provider.configured || provider.active || provider.oauthReady || provider.pendingLogin || provider.activeRoute !== 'unconfigured',
+  );
+  const providerRouteLabel = routing
+    ? `${routing.primaryProviderId}/${routing.primaryModelId}`
+    : 'Not loaded';
+  const activeSubscriptionProviders = activeSubscriptions.map((subscription) => subscription.provider);
+  const pendingSubscriptionProviders = pendingSubscriptions.map((subscription) => subscription.provider);
   const fields: OnboardingWizardFieldDefinition[] = [
     {
       kind: 'status',
-      id: 'providers.openai-subscription',
-      label: 'OpenAI subscription status',
-      hint: openAiActive
-        ? 'An OpenAI subscription session is already available.'
-        : openAiPending
-          ? 'An OpenAI subscription login is pending.'
-          : 'No OpenAI subscription session was found in the current Agent state.',
-      defaultValue: openAiActive ? 'Active' : openAiPending ? 'Pending' : 'Not detected',
+      id: 'providers.default-route',
+      label: 'Current conversation route',
+      hint: 'Normal Agent turns use this provider/model until you change the default model route.',
+      defaultValue: providerRouteLabel,
+    },
+    {
+      kind: 'status',
+      id: 'providers.account-routes',
+      label: 'Provider account routes',
+      hint: configuredAccounts.length > 0
+        ? formatBoundedList(configuredAccounts.map(providerAccountLabel), 'No provider account routes detected.')
+        : 'No provider account routes were detected in the current Agent state.',
+      defaultValue: configuredAccounts.length > 0 ? `${configuredAccounts.length} route(s)` : 'None detected',
+    },
+    {
+      kind: 'status',
+      id: 'providers.subscription-sessions',
+      label: 'Subscription sessions',
+      hint: [
+        `active: ${formatBoundedList(activeSubscriptionProviders, 'none')}`,
+        `pending: ${formatBoundedList(pendingSubscriptionProviders, 'none')}`,
+      ].join('  '),
+      defaultValue: `${activeSubscriptions.length} active / ${pendingSubscriptions.length} pending`,
     },
     {
       kind: 'status',
@@ -364,10 +321,10 @@ export function buildProviderAccessStep(controller: OnboardingWizardController):
     {
       kind: 'masked',
       id: 'providers.openai-api-key',
-      label: 'OpenAI API key',
+      label: 'OpenAI API key quick start',
       hint: openAiApiKeyConfigured
-        ? 'An OpenAI API key is already stored. Leave blank to keep it; enter a new key to replace it through the secret manager.'
-        : 'Optional: enter an OpenAI API key now. The value is stored through the secret manager, not in config.',
+        ? 'Optional quick start: an OpenAI API key is already stored. Leave blank to keep it; enter a new key to replace it through the secret manager.'
+        : 'Optional quick start: enter an OpenAI API key now. Other providers can be configured from /secrets, /provider, and the model picker.',
       placeholder: openAiApiKeyConfigured ? 'already configured' : 'sk-...',
       defaultValue: '',
     },
@@ -413,11 +370,12 @@ export function buildProviderAccessStep(controller: OnboardingWizardController):
     id: 'provider-access',
     title: 'AI provider access',
     shortLabel: 'Providers',
-    description: 'Review provider access for the Agent conversation. Credentials stay masked and are stored through the secret manager.',
+    description: 'Review provider and model access for the Agent conversation. Credentials stay masked and provider-specific setup remains configurable.',
     summaryTitle: 'Provider access summary',
     summaryLines: [
-      `OpenAI subscription: ${openAiActive ? 'active' : openAiPending ? 'pending' : 'not detected'}`,
-      `OpenAI API key: ${openAiApiKeyConfigured ? 'configured' : 'not detected'}`,
+      `Default route: ${providerRouteLabel}`,
+      `Provider account routes: ${configuredAccounts.length}`,
+      `Subscription sessions: ${activeSubscriptions.length} active / ${pendingSubscriptions.length} pending`,
       `Provider credential references: ${providerSecretCount}`,
     ],
     fields,
@@ -461,210 +419,6 @@ export function buildDefaultModelStep(controller: OnboardingWizardController): O
   };
 }
 
-export function buildAgentKnowledgeStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-knowledge',
-    title: 'Agent Knowledge',
-    shortLabel: 'Knowledge',
-    description: 'Agent Knowledge is isolated to the GoodVibes Agent product segment. It never falls back to default Knowledge/Wiki or any non-Agent product segment.',
-    summaryTitle: 'Knowledge isolation',
-    summaryLines: [
-      'Route segment: /api/goodvibes-agent/knowledge/*',
-      'Default wiki fallback: disabled',
-      'Non-Agent route fallback: disabled',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-knowledge.route',
-        label: 'Isolated Agent Knowledge route',
-        hint: 'Ask, search, status, and ingest use /api/goodvibes-agent/knowledge/* only.',
-        defaultValue: 'Isolated',
-      },
-      {
-        kind: 'status',
-        id: 'agent-knowledge.no-default-wiki',
-        label: 'Default Knowledge/Wiki fallback',
-        hint: 'Agent setup and Agent ask/search must not query the default wiki when Agent Knowledge has no answer.',
-        defaultValue: 'Blocked',
-      },
-      {
-        kind: 'status',
-        id: 'agent-knowledge.no-non-agent-routes',
-        label: 'Non-Agent route fallback',
-        hint: 'Other product routes are not part of Agent Knowledge.',
-        defaultValue: 'Blocked',
-      },
-    ],
-  };
-}
-
-export function buildLocalStateStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-local-state',
-    title: 'Local memory and behavior',
-    shortLabel: 'Memory',
-    description: 'Review the Agent-local behavior model. Memory, personas, skills, routines, and Agent profiles stay local until a stable shared registry exists.',
-    summaryTitle: 'Local Agent state',
-    summaryLines: [
-      'Memory/personas/skills/routines: local Agent registries',
-      'Secrets: rejected or stored by secret reference',
-      'Profiles: isolated Agent homes',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-local-state.memory',
-        label: 'Local memory',
-        hint: 'Use /memory to create, review, stale, search, and delete Agent-local memory records.',
-        defaultValue: 'Local registry',
-      },
-      {
-        kind: 'status',
-        id: 'agent-local-state.personas',
-        label: 'Personas',
-        hint: 'Use /personas to create and activate serial operating modes for the main conversation.',
-        defaultValue: 'Local registry',
-      },
-      {
-        kind: 'status',
-        id: 'agent-local-state.skills',
-        label: 'Skills',
-        hint: 'Use /agent-skills and /skills local to manage reusable Agent procedures.',
-        defaultValue: 'Local registry',
-      },
-      {
-        kind: 'status',
-        id: 'agent-local-state.routines',
-        label: 'Routines',
-        hint: 'Use /routines for reusable local procedures. Starting a routine prints steps in the main conversation and does not spawn hidden work.',
-        defaultValue: 'Local registry',
-      },
-    ],
-  };
-}
-
-export function buildAutomationStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-automation',
-    title: 'Routines and automation',
-    shortLabel: 'Routines',
-    description: 'Set the Agent automation posture: local routines run in the main conversation, while external schedules remain explicit.',
-    summaryTitle: 'Routine and schedule posture',
-    summaryLines: [
-      'Local routines: reusable main-conversation workflows',
-      'External schedules: explicit promotion only',
-      'Runs/cancels/retries: command-confirmed side effects',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-automation.local-routines',
-        label: 'Local routine library',
-        hint: 'Use /routines or the Agent workspace to create, review, enable, and start local routines without spawning hidden jobs.',
-        defaultValue: 'Local registry',
-      },
-      {
-        kind: 'status',
-        id: 'agent-automation.schedule-observability',
-        label: 'Schedule observability',
-        hint: 'Use /schedule list, /schedule reconcile, and automation views to inspect externally owned jobs and runs.',
-        defaultValue: 'Read first',
-      },
-      {
-        kind: 'status',
-        id: 'agent-automation.schedule-promotion',
-        label: 'Routine-to-schedule promotion',
-        hint: 'Creating external schedules from routines requires a reviewed routine, a real timing expression, optional delivery target, and explicit confirmation.',
-        defaultValue: 'Explicit command',
-      },
-      {
-        kind: 'status',
-        id: 'agent-automation.mutations',
-        label: 'Automation mutations',
-        hint: 'Run, pause, resume, cancel, retry, approve, and deny actions are never inferred from chat; they require exact commands and confirmation.',
-        defaultValue: 'Confirmed only',
-      },
-    ],
-  };
-}
-
-export function buildVoiceMediaStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-voice-media',
-    title: 'Voice and media',
-    shortLabel: 'Voice',
-    description: 'Prepare voice, speech, image input, and media understanding as Agent operator tools rather than runtime lifecycle features.',
-    summaryTitle: 'Voice and media posture',
-    summaryLines: [
-      'Voice and speech: optional operator tools',
-      'Image/audio inputs: explicit attachment workflows',
-      'Media generation and playback: provider-backed and policy-gated',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-voice-media.voice',
-        label: 'Voice interaction',
-        hint: 'Use the voice/media workspace and TTS settings to configure spoken responses for the Agent conversation.',
-        defaultValue: 'Optional',
-      },
-      {
-        kind: 'status',
-        id: 'agent-voice-media.attachments',
-        label: 'Image and audio input',
-        hint: 'Attach files explicitly to a prompt or command. Agent does not ingest media into Knowledge without an Agent Knowledge ingest action.',
-        defaultValue: 'Explicit input',
-      },
-      {
-        kind: 'status',
-        id: 'agent-voice-media.output',
-        label: 'Generated media and playback',
-        hint: 'Media output uses configured providers and visible command/turn flow; external publication still requires explicit approval.',
-        defaultValue: 'Policy gated',
-      },
-    ],
-  };
-}
-
-export function buildDelegationPolicyStep(): OnboardingWizardStepDefinition {
-  return {
-    id: 'agent-delegation',
-    title: 'Build delegation',
-    shortLabel: 'Delegate',
-    description: 'GoodVibes Agent is not the coding TUI. Explicit build, fix, review, or implementation work is delegated to GoodVibes TUI; ordinary assistant work stays serial in this conversation.',
-    summaryTitle: 'Delegation policy',
-    summaryLines: [
-      'Normal chat: main Agent conversation',
-      'Build/fix/review: explicit GoodVibes TUI delegation',
-      'WRFC: only when explicitly requested for build/fix/review',
-    ],
-    fields: [
-      {
-        kind: 'status',
-        id: 'agent-delegation.normal-chat',
-        label: 'Normal assistant work',
-        hint: 'Planning, research, summaries, local memory updates, and safe read-only checks stay in the main Agent conversation.',
-        defaultValue: 'Serial',
-      },
-      {
-        kind: 'status',
-        id: 'agent-delegation.build-work',
-        label: 'Build/fix/review work',
-        hint: 'Use /delegate with the full original task. GoodVibes TUI owns coding execution and WRFC chains.',
-        defaultValue: 'Explicit delegation',
-      },
-      {
-        kind: 'status',
-        id: 'agent-delegation.wrfc',
-        label: 'WRFC policy',
-        hint: 'Agent never uses WRFC by default; request it only for explicit build, fix, review, or implementation work.',
-        defaultValue: 'Explicit only',
-      },
-    ],
-  };
-}
-
 export function buildExperienceStep(controller: OnboardingWizardController): OnboardingWizardStepDefinition {
   return {
     id: 'experience',

package/src/main.ts

@@ -289,7 +289,7 @@ async function main() {
     if (processedText.startsWith('!#')) {
       const memoryText = processedText.slice(2).trim();
       if (!memoryText) {
-        systemMessageRouter.high('[Memory] Usage: !# <text to pin as session memory>');
+        systemMessageRouter.high('[Memory] Usage: !# <text to pin as conversation-pinned memory>');
         render();
         processedText = '';
       } else {

package/src/renderer/help-overlay.ts

@@ -70,7 +70,7 @@ export function renderHelpOverlay(
   // Commands not registered in the live registry are omitted at render time.
   const FEATURED_COMMANDS: Array<[name: string, argHint: string, desc: string]> = [
     ['agent',        '',           'Open the Agent operator workspace'],
-    ['onboarding',   '',           'Open Agent setup with current settings preloaded'],
+    ['setup',        '',           'Open Agent setup with current settings preloaded'],
     ['knowledge',    'status',     'Inspect isolated Agent Knowledge readiness'],
     ['memory',       '',           'Manage local Agent memory records'],
     ['personas',     '',           'Manage serial Agent operating personas'],
@@ -119,7 +119,7 @@ export function renderHelpOverlay(
     commandRows.push('', '  Available Slash Commands', '  ' + '\u2500'.repeat(40));
     const preferred = [
       'agent',
-      'onboarding',
+      'setup',
       'knowledge',
       'memory',
       'personas',
@@ -238,7 +238,7 @@ export function renderShortcutsOverlay(
     row(kb('clear-prompt'), 'Clear prompt'),
     row(kb('delete-word'), 'Delete word backward'),
     row(kb('kill-line'), 'Kill to end of line'),
-    row(kb('apply-diff-line-start'), 'Diff apply blocked / line start'),
+    row(kb('apply-diff-line-start'), 'Delegate diff changes / line start'),
     row(kb('next-error-line-end'), 'Next error / line end'),
     '',
     '  Actions',
@@ -246,7 +246,7 @@ export function renderShortcutsOverlay(
     row('Tab', 'Collapse/expand block'),
     row(kb('bookmark'), 'Bookmark block'),
     row(kb('block-copy'), 'Copy block to clipboard'),
-    row(kb('block-save'), 'Block save blocked; use /share --yes'),
+    row(kb('block-save'), 'Block file save disabled; copy or export'),
     row(kb('copy-selection'), 'Copy selection'),
     row('F2', 'Process monitor'),
     row('?', 'Help overlay'),

package/src/renderer/settings-modal.ts

@@ -31,7 +31,7 @@ const CATEGORY_INFO: Record<SettingsCategory, string> = {
   storage: 'Local storage posture, including secret storage policy and maximum artifact size for Agent Knowledge, artifacts, and document ingestion.',
   permissions: 'Permission mode and tool-class policy. These settings decide whether the shell prompts before read/write/exec/network/agent actions.',
   orchestration: 'Agent orchestration limits and recursion controls.',
-  wrfc: 'WRFC is external to normal Agent operation. Review these copied compatibility values only for explicit GoodVibes TUI build delegation.',
+  wrfc: 'WRFC is external to normal Agent operation. Review these runtime compatibility values only for explicit GoodVibes TUI build delegation.',
   helper: 'Helper model defaults used by helper subsystems when they do not use the main chat route.',
   tts: 'Text-to-speech provider, voice, and optional spoken-turn LLM overrides.',
   service: 'External runtime installation posture. Agent shows these compatibility keys for inspection only and does not install, start, stop, restart, or autostart anything.',

package/src/runtime/bootstrap.ts

@@ -553,8 +553,8 @@ export async function bootstrapRuntime(
   };
 
   // ── Phase 12b: Operator intervention wiring (feature-gated) ──────────────
-  // Keep the copied control-plane state internal. GoodVibes Agent does not
-  // expose the copied local ops-control panel; operator control is surfaced
+  // Keep runtime-owned control-plane state internal. GoodVibes Agent does not
+  // expose the local ops-control panel; operator control is surfaced
   // through Agent-owned status, approvals, automation, and delegation flows.
   ctx.commandContext.ops.acpManager = acpManager;
 

package/src/tools/agent-context-policy.ts

@@ -1,16 +1,16 @@
 import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
 
 const CONTEXT_TOOL_DENIAL = [
-  'GoodVibes Agent does not expose copied GoodVibes runtime context through model tools in the main conversation.',
-  'The copied context tool can describe TUI/default runtime assumptions that are not the Agent product boundary.',
+  'GoodVibes Agent does not expose non-Agent runtime context through model tools in the main conversation.',
+  'The runtime context tool can describe assumptions that are outside the Agent product boundary.',
   'Use explicit Agent CLI/slash commands such as status, compat, setup, and isolated Agent Knowledge instead.',
 ].join(' ');
 
 export function wrapBlockedContextToolForAgentPolicy(tool: Tool): void {
   tool.definition.description = [
-    'Blocked in GoodVibes Agent main conversation: copied runtime context.',
+    'Blocked in GoodVibes Agent main conversation: non-Agent runtime context.',
     'Use explicit Agent CLI/slash status, compat, setup, and Agent Knowledge commands for product-scoped context.',
-    'Default Knowledge/Wiki, non-Agent knowledge segments, and copied TUI runtime assumptions are not Agent fallbacks.',
+    'Default Knowledge/Wiki, non-Agent knowledge segments, and non-Agent runtime assumptions are not Agent fallbacks.',
   ].join(' ');
   tool.definition.sideEffects = [];
   tool.definition.parameters = {

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

@@ -166,8 +166,8 @@ const FETCH_NETWORK_MUTATION_DENIAL = [
 ].join(' ');
 
 const STATE_MUTATION_DENIAL = [
-  'GoodVibes Agent only inspects copied runtime state from the main conversation.',
-  'Arbitrary state set/clear, copied memory writes, hook mutation, output-mode mutation, and analytics writes are disabled here.',
+  'GoodVibes Agent only inspects runtime-owned state from the main conversation.',
+  'Arbitrary state set/clear, runtime-owned memory writes, hook mutation, output-mode mutation, and analytics writes are disabled here.',
   'Use Agent-owned memory, skills, personas, routines, and explicit CLI/slash commands for intentional local state changes.',
 ].join(' ');
 
@@ -184,13 +184,13 @@ const INSPECT_WRITE_DENIAL = [
 ].join(' ');
 
 const DURABLE_WORKFLOW_MUTATION_DENIAL = [
-  'GoodVibes Agent only inspects copied durable workflow tools from the main conversation.',
+  'GoodVibes Agent only inspects runtime-owned durable workflow tools from the main conversation.',
   'Task, team, worklist, packet, and query creation or lifecycle mutation is disabled here.',
   'Use explicit Agent CLI/slash commands or GoodVibes TUI delegation for intentional workflow changes.',
 ].join(' ');
 
 const CONTROL_MUTATION_DENIAL = [
-  'GoodVibes Agent only inspects copied product-control surfaces from the main conversation.',
+  'GoodVibes Agent only inspects runtime-owned product-control surfaces from the main conversation.',
   'Product-control mutation, daemon lifecycle, and service posture changes are disabled here.',
   'Use explicit Agent CLI/slash commands for Agent-owned changes, and keep daemon lifecycle external.',
 ].join(' ');
@@ -290,7 +290,7 @@ export function installAgentToolPolicyGuard(registry: ToolRegistry, options: Age
       wrapModeRestrictedToolForAgentPolicy(tool, {
         allowedModes: READ_ONLY_QUERY_TOOL_MODES,
         modeSet: READ_ONLY_QUERY_TOOL_MODE_SET,
-        description: 'Read-only operator query inspection for GoodVibes Agent. Asking, answering, and closing copied workflow queries are disabled in the main conversation.',
+        description: 'Read-only operator query inspection for GoodVibes Agent. Asking, answering, and closing runtime-owned workflow queries are disabled in the main conversation.',
         denial: DURABLE_WORKFLOW_MUTATION_DENIAL,
         removedProperties: ['prompt', 'askedBy', 'target', 'answer', 'resolution'],
       });
@@ -701,8 +701,8 @@ function narrowFetchToolDefinitionForAgentPolicy(tool: Tool): void {
 
 function narrowStateToolDefinitionForAgentPolicy(tool: Tool): void {
   tool.definition.description = [
-    'Inspect copied runtime state for GoodVibes Agent.',
-    'State mutation, copied memory writes, hook changes, output-mode changes, and analytics writes are disabled in the main conversation.',
+    'Inspect runtime-owned state for GoodVibes Agent.',
+    'State mutation, runtime-owned memory writes, hook changes, output-mode changes, and analytics writes are disabled in the main conversation.',
     'Use Agent-owned commands for intentional memory, skill, persona, and routine changes.',
   ].join(' ');
 
@@ -711,7 +711,7 @@ function narrowStateToolDefinitionForAgentPolicy(tool: Tool): void {
   const modeProperty = properties.mode;
   if (isRecord(modeProperty)) {
     modeProperty.enum = [...READ_ONLY_STATE_TOOL_MODES];
-    modeProperty.description = 'Read-only copied runtime state mode. set and clear are disabled in GoodVibes Agent.';
+    modeProperty.description = 'Read-only runtime-owned state mode. set and clear are disabled in GoodVibes Agent.';
   }
 
   delete properties.values;
@@ -727,7 +727,7 @@ function narrowStateToolDefinitionForAgentPolicy(tool: Tool): void {
   delete properties.analyticsTokens;
   delete properties.analyticsFormat;
 
-  narrowStringEnumProperty(properties, 'memoryAction', READ_ONLY_STATE_MEMORY_ACTIONS, 'Read-only copied memory actions allowed by GoodVibes Agent.');
+  narrowStringEnumProperty(properties, 'memoryAction', READ_ONLY_STATE_MEMORY_ACTIONS, 'Read-only runtime-owned memory actions allowed by GoodVibes Agent.');
   narrowStringEnumProperty(properties, 'hookAction', READ_ONLY_STATE_HOOK_ACTIONS, 'Read-only hook action allowed by GoodVibes Agent.');
   narrowStringEnumProperty(properties, 'modeAction', READ_ONLY_STATE_MODE_ACTIONS, 'Read-only mode actions allowed by GoodVibes Agent.');
   narrowStringEnumProperty(properties, 'analyticsAction', READ_ONLY_STATE_ANALYTICS_ACTIONS, 'Read-only analytics actions allowed by GoodVibes Agent.');

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.105';
+let _version = '0.1.107';
 let _sdkVersion = '0.33.35';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {