@pellux/goodvibes-agent 1.0.31 → 1.0.34

package/src/agent/harness-control.ts

@@ -77,6 +77,18 @@ export interface HarnessSettingDescriptor {
   readonly lookup?: HarnessSettingLookup;
 }
 
+export interface HarnessSettingSummary {
+  readonly key: string;
+  readonly category: string;
+  readonly type: ConfigSetting['type'];
+  readonly value: unknown;
+  readonly configured: boolean;
+  readonly writable: boolean;
+  readonly visibleInWorkspace: boolean;
+  readonly summary: string;
+  readonly enumValues?: readonly string[];
+}
+
 export interface HarnessSettingMutationResult {
   readonly key: string;
   readonly action: 'set' | 'reset';
@@ -91,6 +103,11 @@ function valuesEqual(left: unknown, right: unknown): boolean {
   return JSON.stringify(left) === JSON.stringify(right);
 }
 
+function previewText(value: string, maxLength = 120): string {
+  const normalized = value.replace(/\s+/g, ' ').trim();
+  return normalized.length <= maxLength ? normalized : `${normalized.slice(0, maxLength - 1).trimEnd()}...`;
+}
+
 function clampLimit(value: unknown, fallback = DEFAULT_SETTING_LIMIT): number {
   if (typeof value !== 'number' || !Number.isFinite(value)) return fallback;
   return Math.max(1, Math.min(500, Math.trunc(value)));
@@ -164,10 +181,30 @@ export function describeHarnessSetting(
   };
 }
 
+export function describeHarnessSettingSummary(
+  configManager: Pick<ConfigManager, 'get'>,
+  setting: ConfigSetting,
+): HarnessSettingSummary {
+  const value = configManager.get(setting.key as ConfigKey);
+  const hostOwned = isExternalHostOwnedSettingKey(setting.key);
+  return {
+    key: setting.key,
+    category: setting.key.split('.')[0] ?? '',
+    type: setting.type,
+    value: redactHarnessSettingValue(setting.key, value),
+    configured: !valuesEqual(value, setting.default),
+    writable: !hostOwned,
+    visibleInWorkspace: !isAgentHiddenSettingKey(setting.key),
+    summary: previewText(setting.description),
+    ...(setting.enumValues ? { enumValues: setting.enumValues } : {}),
+  };
+}
+
 export function listHarnessSettings(
   configManager: Pick<ConfigManager, 'get' | 'getSchema'>,
   filters: HarnessSettingFilters = {},
-): readonly HarnessSettingDescriptor[] {
+  options: { readonly includeParameters?: boolean } = {},
+): readonly (HarnessSettingDescriptor | HarnessSettingSummary)[] {
   const key = filters.key?.trim();
   const category = filters.category?.trim();
   const prefix = filters.prefix?.trim();
@@ -185,7 +222,9 @@ export function listHarnessSettings(
       }
       return true;
     })
-    .map((setting) => describeHarnessSetting(configManager, setting))
+    .map((setting) => options.includeParameters
+      ? describeHarnessSetting(configManager, setting)
+      : describeHarnessSettingSummary(configManager, setting))
     .slice(0, limit);
 }
 
@@ -358,7 +397,7 @@ export async function resetHarnessSetting(
   };
 }
 
-export function formatHarnessSettingList(settings: readonly HarnessSettingDescriptor[]): string {
+export function formatHarnessSettingList(settings: readonly (HarnessSettingDescriptor | HarnessSettingSummary)[]): string {
   if (settings.length === 0) return 'No settings matched.';
   return [
     `Settings (${settings.length})`,

package/src/cli/agent-knowledge-command.ts

@@ -160,7 +160,7 @@ export async function handleAgentKnowledgeCommand(runtime: CliCommandRuntime): P
     const [id] = commandValues(rest);
     if (!id) return { output: 'Usage: goodvibes-agent knowledge get <source|node|issue id>', exitCode: 2 };
     const route = `/api/goodvibes-agent/knowledge/items/${encodeURIComponent(id)}`;
-    const result = await runKnowledgeCall(runtime, AGENT_KNOWLEDGE_METHODS.itemGet, async (connection) => (
+    const result = await runKnowledgeCall(runtime, { ...AGENT_KNOWLEDGE_METHODS.itemGet, route }, async (connection) => (
       await getAgentKnowledgeJson(connection, route)
     ));
     if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };
@@ -189,7 +189,7 @@ export async function handleAgentKnowledgeCommand(runtime: CliCommandRuntime): P
       const id = values[1];
       if (!id) return { output: 'Usage: goodvibes-agent knowledge connectors doctor <connectorId>', exitCode: 2 };
       const route = `/api/goodvibes-agent/knowledge/connectors/${encodeURIComponent(id)}/doctor`;
-      const result = await runKnowledgeCall(runtime, AGENT_KNOWLEDGE_METHODS.connectorDoctor, async (connection) => (
+      const result = await runKnowledgeCall(runtime, { ...AGENT_KNOWLEDGE_METHODS.connectorDoctor, route }, async (connection) => (
         await getAgentKnowledgeJson(connection, route)
       ));
       if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };
@@ -201,7 +201,7 @@ export async function handleAgentKnowledgeCommand(runtime: CliCommandRuntime): P
     const id = values[0];
     if (id) {
       const route = `/api/goodvibes-agent/knowledge/connectors/${encodeURIComponent(id)}`;
-      const result = await runKnowledgeCall(runtime, AGENT_KNOWLEDGE_METHODS.connectorGet, async (connection) => (
+      const result = await runKnowledgeCall(runtime, { ...AGENT_KNOWLEDGE_METHODS.connectorGet, route }, async (connection) => (
         await getAgentKnowledgeJson(connection, route)
       ));
       if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };
@@ -224,7 +224,7 @@ export async function handleAgentKnowledgeCommand(runtime: CliCommandRuntime): P
     const [id] = commandValues(rest);
     if (!id) return { output: 'Usage: goodvibes-agent knowledge connector <connectorId>', exitCode: 2 };
     const route = `/api/goodvibes-agent/knowledge/connectors/${encodeURIComponent(id)}`;
-    const result = await runKnowledgeCall(runtime, AGENT_KNOWLEDGE_METHODS.connectorGet, async (connection) => (
+    const result = await runKnowledgeCall(runtime, { ...AGENT_KNOWLEDGE_METHODS.connectorGet, route }, async (connection) => (
       await getAgentKnowledgeJson(connection, route)
     ));
     if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };
@@ -238,7 +238,7 @@ export async function handleAgentKnowledgeCommand(runtime: CliCommandRuntime): P
     const [id] = commandValues(rest);
     if (!id) return { output: 'Usage: goodvibes-agent knowledge connector-doctor <connectorId>', exitCode: 2 };
     const route = `/api/goodvibes-agent/knowledge/connectors/${encodeURIComponent(id)}/doctor`;
-    const result = await runKnowledgeCall(runtime, AGENT_KNOWLEDGE_METHODS.connectorDoctor, async (connection) => (
+    const result = await runKnowledgeCall(runtime, { ...AGENT_KNOWLEDGE_METHODS.connectorDoctor, route }, async (connection) => (
       await getAgentKnowledgeJson(connection, route)
     ));
     if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };

package/src/cli/agent-knowledge-format.ts

@@ -47,6 +47,7 @@ export function formatAgentKnowledgeFailureKind(kind: string): string {
   if (kind === 'connected_host_unavailable') return 'connected host unavailable';
   if (kind === 'connected_host_route_unavailable') return 'connected host route unavailable';
   if (kind === 'connected_host_error') return 'connected host error';
+  if (kind === 'scope_contamination') return 'scope contamination';
   if (kind === 'version_mismatch') return 'version mismatch';
   return kind.replace(/[_-]+/g, ' ');
 }
@@ -163,6 +164,7 @@ export function formatEntityList(data: unknown, kind: 'sources' | 'nodes' | 'iss
     ...values.slice(0, limit).map((value, index) => (
       kind === 'issues' ? format(value) : `  ${index + 1}. ${format(value)}`
     )),
+    `  route /api/goodvibes-agent/knowledge/${kind}`,
   ].join('\n');
 }
 
@@ -179,6 +181,7 @@ export function formatItem(data: unknown, id: string): string {
       `Agent Knowledge item ${id}`,
       `  ${sourceLine(source)}`,
       relatedKnowledgeCountsLine(relatedEdges, linkedSources, linkedNodes),
+      '  route /api/goodvibes-agent/knowledge/items/{id}',
     ].join('\n');
   }
   if (node) {
@@ -186,6 +189,7 @@ export function formatItem(data: unknown, id: string): string {
       `Agent Knowledge item ${id}`,
       `  ${nodeLine(node)}`,
       relatedKnowledgeCountsLine(relatedEdges, linkedSources, linkedNodes),
+      '  route /api/goodvibes-agent/knowledge/items/{id}',
     ].join('\n');
   }
   if (issue) {
@@ -193,6 +197,7 @@ export function formatItem(data: unknown, id: string): string {
       `Agent Knowledge item ${id}`,
       issueLine(issue),
       relatedKnowledgeCountsLine(relatedEdges, linkedSources, linkedNodes),
+      '  route /api/goodvibes-agent/knowledge/items/{id}',
     ].join('\n');
   }
   return [
@@ -231,6 +236,7 @@ export function formatConnectors(data: unknown): string {
   return [
     `Agent Knowledge connectors (${connectors.length})`,
     ...connectors.map(connectorLine),
+    '  route /api/goodvibes-agent/knowledge/connectors',
   ].join('\n');
 }
 
@@ -299,6 +305,7 @@ export function formatAsk(data: unknown, query: string): string {
   }
   if (facts.length > 0) lines.push('', `Facts ${facts.length}`);
   if (gaps.length > 0) lines.push('', `Gaps ${gaps.length}`);
+  lines.push('', 'route /api/goodvibes-agent/knowledge/ask');
   return lines.join('\n');
 }
 
@@ -316,6 +323,7 @@ export function formatSearch(data: unknown, query: string): string {
   return [
     `Agent Knowledge search ${query}`,
     ...results.slice(0, 10).map((result, index) => `  ${index + 1}. ${resultLine(result)}`),
+    '  route /api/goodvibes-agent/knowledge/search',
   ].join('\n');
 }
 
@@ -385,5 +393,8 @@ export function formatFailure(failure: AgentKnowledgeFailureLike, json: boolean)
     failure.kind === 'connected_host_route_unavailable'
       ? '  next update the connected GoodVibes host to the SDK version required by this Agent package.'
       : null,
+    failure.kind === 'scope_contamination'
+      ? '  next update the connected GoodVibes host so Agent Knowledge routes return only Agent-owned scope data.'
+      : null,
   ].filter((line): line is string => Boolean(line)).join('\n');
 }

package/src/cli/agent-knowledge-runtime.ts

@@ -1,8 +1,7 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
 import { createBrowserAgentSdk } from '@pellux/goodvibes-sdk/browser/agent';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { SDK_VERSION, VERSION } from '../version.ts';
+import { readConnectedHostOperatorToken } from '../runtime/connected-host-auth.ts';
 import type { ConnectedHostCallMethod } from './agent-knowledge-methods.ts';
 
 export type JsonRecord = Record<string, unknown>;
@@ -22,7 +21,13 @@ export interface AgentKnowledgeConnectionRuntime {
 
 export interface AgentKnowledgeFailure {
   readonly ok: false;
-  readonly kind: 'connected_host_unavailable' | 'auth_required' | 'version_mismatch' | 'connected_host_route_unavailable' | 'connected_host_error';
+  readonly kind:
+    | 'connected_host_unavailable'
+    | 'auth_required'
+    | 'version_mismatch'
+    | 'connected_host_route_unavailable'
+    | 'connected_host_error'
+    | 'scope_contamination';
   readonly error: string;
   readonly baseUrl: string;
   readonly route: string;
@@ -56,15 +61,8 @@ export function resolveConnectedHostConnection(runtime: AgentKnowledgeConnection
   const host = String(runtime.configManager.get('controlPlane.host') ?? '127.0.0.1');
   const port = Number(runtime.configManager.get('controlPlane.port') ?? 3421);
   const baseUrl = `http://${host}:${Number.isFinite(port) ? port : 3421}`;
-  const tokenPath = join(runtime.homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
-  if (!existsSync(tokenPath)) return { baseUrl, token: null, tokenPath };
-  try {
-    const parsed = JSON.parse(readFileSync(tokenPath, 'utf-8')) as unknown;
-    const token = isRecord(parsed) && typeof parsed.token === 'string' ? parsed.token : null;
-    return { baseUrl, token, tokenPath };
-  } catch {
-    return { baseUrl, token: null, tokenPath };
-  }
+  const token = readConnectedHostOperatorToken(runtime.homeDirectory);
+  return { baseUrl, token: token.token, tokenPath: token.path };
 }
 
 export async function fetchConnectedHostStatus(connection: AgentKnowledgeConnection): Promise<{ readonly ok: boolean; readonly status: number; readonly body: unknown }> {
@@ -122,6 +120,87 @@ export function createAgentSdk(connection: AgentKnowledgeConnection) {
   });
 }
 
+const AGENT_KNOWLEDGE_SCOPE_KEYS = new Set(['spaceid', 'knowledgespaceid']);
+const AGENT_KNOWLEDGE_SCOPE_TEXT_PATTERNS: readonly { readonly label: string; readonly pattern: RegExp }[] = [
+  {
+    label: 'default knowledge scope id',
+    pattern: /["']?(?:knowledge[-_\s]*space[-_\s]*id|knowledgespaceid|space[-_\s]*id|spaceid)["']?\s*[:=]\s*["']?default["']?/i,
+  },
+  { label: 'host assistant payload marker', pattern: /home\s*assistant/i },
+  { label: 'host graph payload marker', pattern: /home\s*graph|homegraph/i },
+];
+
+function normalizedJsonKey(key: string): string {
+  return key.replace(/[-_\s]/g, '').toLowerCase();
+}
+
+function findAgentKnowledgeTextContamination(value: string): string | null {
+  for (const { label, pattern } of AGENT_KNOWLEDGE_SCOPE_TEXT_PATTERNS) {
+    if (pattern.test(value)) return label;
+  }
+  return null;
+}
+
+export function findAgentKnowledgeScopeContamination(value: unknown): string | null {
+  const seen = new WeakSet<object>();
+  const visit = (node: unknown): string | null => {
+    if (typeof node === 'string') return findAgentKnowledgeTextContamination(node);
+    if (!node || typeof node !== 'object') return null;
+    if (seen.has(node)) return null;
+    seen.add(node);
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        const nested = visit(item);
+        if (nested) return nested;
+      }
+      return null;
+    }
+    for (const [key, nestedValue] of Object.entries(node as JsonRecord)) {
+      const keyFinding = findAgentKnowledgeTextContamination(key);
+      if (keyFinding && keyFinding !== 'default knowledge scope id') return keyFinding;
+      const normalizedKey = normalizedJsonKey(key);
+      if (
+        AGENT_KNOWLEDGE_SCOPE_KEYS.has(normalizedKey)
+        && typeof nestedValue === 'string'
+        && nestedValue.trim().toLowerCase() === 'default'
+      ) {
+        return `${key}=default`;
+      }
+      const nested = visit(nestedValue);
+      if (nested) return nested;
+    }
+    return null;
+  };
+  return visit(value);
+}
+
+export function agentKnowledgeScopeContaminationFailure(
+  connection: AgentKnowledgeConnection,
+  route: string,
+  finding: string,
+): AgentKnowledgeFailure {
+  return {
+    ok: false,
+    kind: 'scope_contamination',
+    error: [
+      `Agent Knowledge route returned non-Agent knowledge contamination (${finding}).`,
+      'GoodVibes Agent must use only isolated /api/goodvibes-agent/knowledge/* scope data.',
+    ].join(' '),
+    baseUrl: connection.baseUrl,
+    route,
+  };
+}
+
+export function validateAgentKnowledgeData<TData>(
+  data: TData,
+  connection: AgentKnowledgeConnection,
+  method: ConnectedHostCallMethod,
+): AgentKnowledgeResult<TData> {
+  const contamination = findAgentKnowledgeScopeContamination(data);
+  if (contamination) return agentKnowledgeScopeContaminationFailure(connection, method.route, contamination);
+  return { ok: true, kind: method.kind, route: method.route, data };
+}
+
 export async function postAgentKnowledgeJson<TData>(
   connection: AgentKnowledgeConnection,
   route: string,
@@ -239,7 +318,7 @@ export async function runKnowledgeCall<TData>(
   }
   try {
     const data = await call(connection);
-    return { ok: true, kind: method.kind, route: method.route, data };
+    return validateAgentKnowledgeData(data, connection, method);
   } catch (error) {
     return classifyKnowledgeError(error, connection, method.route);
   }

package/src/cli/bundle-command.ts

@@ -1,10 +1,11 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname } from 'node:path';
 import { RuntimeEventBus } from '@/runtime/index.ts';
 import { createShellPathService } from '@/runtime/index.ts';
 import { listProviderRuntimeSnapshots } from '@pellux/goodvibes-sdk/platform/providers';
 import { createRuntimeServices } from '../runtime/services.ts';
 import { createRuntimeStore } from '../runtime/store/index.ts';
+import { readConnectedHostOperatorToken } from '../runtime/connected-host-auth.ts';
 import { getOnboardingCheckMarkerPath } from '../runtime/onboarding/index.ts';
 import { CONFIG_SCHEMA } from '../config/index.ts';
 import { SecretsManager } from '../config/secrets.ts';
@@ -76,14 +77,14 @@ function readAuthPosture(runtime: CliCommandRuntime) {
   });
   const userStorePath = shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'auth-users.json');
   const bootstrapCredentialPath = shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'auth-bootstrap.txt');
-  const operatorTokenPath = join(runtime.homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+  const operatorToken = readConnectedHostOperatorToken(runtime.homeDirectory);
   return {
     userStorePath,
     userStorePresent: existsSync(userStorePath),
     bootstrapCredentialPath,
     bootstrapCredentialPresent: existsSync(bootstrapCredentialPath),
-    operatorTokenPath,
-    operatorTokenPresent: existsSync(operatorTokenPath),
+    operatorTokenPath: operatorToken.path,
+    operatorTokenPresent: operatorToken.present && Boolean(operatorToken.token),
   };
 }
 

package/src/cli/entrypoint.ts

@@ -186,6 +186,9 @@ export async function prepareShellCliRuntime(
       configManager,
       homeDirectory: bootstrapHomeDirectory,
     });
+    const effectiveOperatorTokenPath = externalRuntime.operatorToken.present
+      ? externalRuntime.operatorToken.path
+      : operatorTokenPath;
     const statusOptions = {
       configManager,
       workingDirectory: bootstrapWorkingDir,
@@ -196,8 +199,8 @@ export async function prepareShellCliRuntime(
         userStorePresent: existsSync(userStorePath),
         bootstrapCredentialPath,
         bootstrapCredentialPresent: existsSync(bootstrapCredentialPath),
-        operatorTokenPath,
-        operatorTokenPresent: existsSync(operatorTokenPath),
+        operatorTokenPath: effectiveOperatorTokenPath,
+        operatorTokenPresent: externalRuntime.operatorToken.present,
       },
       service,
       externalRuntime,

package/src/cli/external-runtime.ts

@@ -1,8 +1,7 @@
-import { existsSync, readFileSync } from 'node:fs';
-import { join } from 'node:path';
 import type { ConfigManager } from '@pellux/goodvibes-sdk/platform/config';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { SDK_VERSION } from '../version.ts';
+import { readConnectedHostOperatorToken } from '../runtime/connected-host-auth.ts';
 
 type JsonRecord = Record<string, unknown>;
 
@@ -47,18 +46,6 @@ function resolveBaseUrl(configManager: Pick<ConfigManager, 'get'>): string {
   return `http://${host}:${Number.isFinite(port) ? port : 3421}`;
 }
 
-function readOperatorToken(homeDirectory: string): { readonly token: string | null; readonly path: string } {
-  const path = join(homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
-  if (!existsSync(path)) return { token: null, path };
-  try {
-    const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
-    const token = isRecord(parsed) && typeof parsed.token === 'string' ? parsed.token : null;
-    return { token, path };
-  } catch {
-    return { token: null, path };
-  }
-}
-
 async function fetchJson(
   url: string,
   token: string | null,
@@ -90,7 +77,7 @@ export async function inspectCliExternalRuntime(
   options: CliExternalRuntimeInspectionOptions,
 ): Promise<CliExternalRuntimeSnapshot> {
   const baseUrl = resolveBaseUrl(options.configManager);
-  const token = readOperatorToken(options.homeDirectory);
+  const token = readConnectedHostOperatorToken(options.homeDirectory);
   const timeoutMs = options.timeoutMs ?? 1500;
   const route = '/api/goodvibes-agent/knowledge/status' as const;
 

package/src/cli/management.ts

@@ -9,6 +9,7 @@ import { formatProviderModel, getModelIdFromProviderModel } from '../config/prov
 import { bootstrapRuntime } from '../runtime/bootstrap.ts';
 import { createRuntimeServices } from '../runtime/services.ts';
 import { createRuntimeStore } from '../runtime/store/index.ts';
+import { readConnectedHostOperatorToken } from '../runtime/connected-host-auth.ts';
 import type { RuntimeServices } from '../runtime/services.ts';
 import { SecretsManager } from '../config/secrets.ts';
 import { RuntimeEventBus, type TurnEvent } from '@/runtime/index.ts';
@@ -190,14 +191,14 @@ export function readAuthPaths(runtime: CliCommandRuntime) {
   });
   const userStorePath = shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'auth-users.json');
   const bootstrapCredentialPath = shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'auth-bootstrap.txt');
-  const operatorTokenPath = join(runtime.homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+  const operatorToken = readConnectedHostOperatorToken(runtime.homeDirectory);
   return {
     userStorePath,
     userStorePresent: existsSync(userStorePath),
     bootstrapCredentialPath,
     bootstrapCredentialPresent: existsSync(bootstrapCredentialPath),
-    operatorTokenPath,
-    operatorTokenPresent: existsSync(operatorTokenPath),
+    operatorTokenPath: operatorToken.path,
+    operatorTokenPresent: operatorToken.present && Boolean(operatorToken.token),
   };
 }
 

package/src/input/commands/guidance-runtime.ts

@@ -21,7 +21,7 @@ export function registerGuidanceRuntimeCommands(registry: CommandRegistry): void
           'Welcome To GoodVibes Agent',
           '  /setup              - open Agent setup with current settings preloaded',
           '  /agent              - open the Agent operator workspace',
-          '  /knowledge          - inspect isolated Agent Knowledge status, ask, and search',
+          '  /knowledge          - inspect isolated Agent Knowledge status, ask/search, libraries, map, connectors, and ingest paths',
           '  /memory             - manage Agent-local memory',
           '  /personas           - manage Agent-local personas',
           '  /skills       - manage reusable Agent-local skills',

package/src/input/commands/knowledge.ts

@@ -209,9 +209,9 @@ function renderKnowledgeAskResult(result: KnowledgeAskResult): string {
 export const knowledgeCommand: SlashCommand = {
   name: 'knowledge',
   aliases: ['know', 'kb'],
-  description: 'Agent Knowledge: isolated Agent-owned sources, graph, review queue, and compact prompt packets.',
+  description: 'Agent Knowledge: isolated Agent-owned status, ask/search, source/node/issue lists, item lookup, map, connectors, ingest, and review queue.',
   usage: '<subcommand> [args]',
-  argsHint: 'status|ask|ingest-url --yes|ingest-file --yes|import-bookmarks --yes|list|search|get|queue|review-issue --yes',
+  argsHint: 'status|ask|search|list|get|map|connectors|connector|connector-doctor|ingest-url --yes|ingest-file --yes|import-urls --yes|import-bookmarks --yes|import-browser-history --yes|ingest-connector --yes|review-issue --yes|reindex --yes',
   handler: async (args: string[], context: CommandContext): Promise<void> => {
     if (args.length === 0 && context.openAgentWorkspace) {
       context.openAgentWorkspace('knowledge');

package/src/runtime/bootstrap.ts

@@ -46,24 +46,16 @@ import { registerAgentHarnessTool } from '../tools/agent-harness-tool.ts';
 
 const GOODVIBES_AGENT_OPERATOR_POLICY = [
   '## GoodVibes Agent Operator Policy',
-  '- Default to serial, proactive assistant work in the main conversation. Answer, inspect, summarize, remember useful non-secret facts, configure Agent-local state, use read-only connected-host/operator routes, and take safe non-destructive actions without creating separate Agent jobs or GoodVibes TUI delegations.',
-  '- GoodVibes Agent connects to a GoodVibes host owned outside this package. Do not start, stop, restart, install, expose, or mutate connected-host network/listener posture from Agent.',
-  '- Use the `agent_operator_briefing` tool for read-only main-conversation summaries of connected work plan, approvals, automation, schedules, and scheduler capacity. This tool must not call mutation routes, connected-host lifecycle routes, default knowledge, non-Agent knowledge spaces, separate Agent job creation, or GoodVibes TUI delegation.',
-  '- When the user explicitly asks Agent to approve, deny, or cancel a specific approval, run/pause/resume a specific automation job, cancel/retry a specific automation run, or run a specific schedule, use the `agent_operator_action` tool with confirm:true and the original user request. It can call only its allowlisted public operator routes and must not create, edit, delete, or discover automation definitions.',
-  '- Use the `agent_work_plan` tool to keep the visible Agent-local work plan current while working in the main conversation. Create, inspect, and update local work items proactively when useful. Removing items or clearing completed items requires an explicit user request and confirm:true.',
-  '- Use the `agent_harness` tool to inspect and operate the harness surface itself: Agent workspace action catalog, slash command catalog, model tool catalog, connected-host posture, and Agent settings. Use it to change Agent settings, invoke workspace action mirrors, or invoke slash-command mirrors only when the user explicitly asks; preserve confirm:true and explicitUserRequest for mutations, keep secret-backed settings in the secret manager, and keep connected-host lifecycle/posture externally owned.',
-  '- Use the `agent_knowledge` tool for Agent Knowledge status, ask, and search from the main conversation. It must use only /api/goodvibes-agent/knowledge/* and must fail closed instead of falling back to default knowledge or non-Agent knowledge spaces.',
-  '- When the user explicitly asks Agent to add, import, remember, or ingest a URL, URL-list file, local file, bookmarks file, browser history, or connector input into Agent Knowledge, use the `agent_knowledge_ingest` tool with confirm:true and the original user request. It must write only to /api/goodvibes-agent/knowledge/* ingest routes and never to default knowledge or non-Agent knowledge spaces.',
-  '- Use the `agent_local_registry` tool when a scratchpad note, durable memory, reusable persona, skill, skill bundle, or routine would improve later work. Keep those records Agent-local, non-secret, source/provenance tagged, and reviewable. Notes are for temporary/source-triage context; promote them explicitly into memory, skills, personas, routines, or Agent Knowledge only when that is the correct durable home. Review memory with a confidence score when it should shape later turns. Starting a routine means applying its steps in this same serial conversation, not creating a background job.',
-  '- When the user explicitly asks Agent to generate an image, video, or other media artifact, use the `agent_media_generate` tool with confirm:true and the original user request. Generated media is stored as artifacts; do not print base64, call default knowledge, use non-Agent knowledge spaces, send channels, create separate Agent jobs, or request GoodVibes TUI delegation for media generation.',
-  '- When the user explicitly asks Agent to send an alert, message, or notification to configured notification targets, use the `agent_notify` tool with confirm:true and the original user request. Do not infer external notifications from vague suggestions, and never create channel routes or account authorizations from the main conversation.',
-  '- When the user explicitly asks Agent to send one message to a specific configured channel, route, webhook, or link target, use the `agent_channel_send` tool with confirm:true and the original user request. It can deliver one message through configured delivery strategies, but must not create routes, authorize accounts, manage connected-host hosting, use default knowledge, use non-Agent knowledge spaces, create separate Agent jobs, or request GoodVibes TUI delegation.',
-  '- When the user explicitly asks for a reminder or asks Agent to schedule a reminder, use the `agent_reminder_schedule` tool with confirm:true and the original user request. That creates one connected schedules.create reminder on the external GoodVibes host. Do not infer reminders from vague suggestions or routine startup, and never create local scheduler jobs.',
-  '- GoodVibes TUI delegation is never the default Agent reasoning path. Do not delegate planning, research, operations, knowledge, memory, configuration, approvals, automation observability, or ordinary assistant work.',
-  '- GoodVibes Agent is not the coding TUI. Do not use the `agent` tool to create coding-role Agent jobs or batch job roots from Agent.',
-  '- When the user explicitly asks to build, implement, fix, patch, or review code, preserve the full original user ask and delegate one build request to GoodVibes TUI through the public shared-session/build-delegation contract. Include clear executionIntent and request delegated review only for explicit build/fix/review work or when the user explicitly asks for delegated Agent review.',
-  '- Do not narrow explicit build/fix/review requests into design-only, read-only, or no-write work unless the user explicitly requested that limitation. TUI owns file edits, git/worktree work, execution isolation UX, and delegated review coordination.',
-  '- If a stable public delegation route is unavailable, say that the task needs GoodVibes TUI delegation and report the missing route instead of pretending to implement it locally or creating sibling Agent jobs.',
+  '- Work serially in the main conversation by default: answer, inspect, summarize, remember useful non-secret facts, configure Agent-local state, and use safe read-only connected-host/operator routes.',
+  '- Connected-host lifecycle is external. Do not start, stop, restart, install, expose, or mutate host listeners/network posture from Agent.',
+  '- Read tools: `agent_operator_briefing` for connected work/approvals/automation/schedules, `agent_knowledge` for isolated Agent Knowledge, `agent_harness` for harness catalogs/settings/status.',
+  '- State tools: `agent_work_plan` for visible local work items; `agent_local_registry` for Agent-local notes, memory, personas, skills, bundles, and routines. Keep records non-secret, sourced, and reviewable.',
+  '- Confirmed tools: use `agent_operator_action`, `agent_knowledge_ingest`, `agent_media_generate`, `agent_notify`, `agent_channel_send`, and `agent_reminder_schedule` only for explicit user requests with confirm:true and explicitUserRequest.',
+  '- Agent Knowledge must use only `/api/goodvibes-agent/knowledge/*` and fail closed. Do not use default knowledge or non-Agent knowledge spaces.',
+  '- External delivery, media generation, reminders, settings writes, slash-command mirrors, workspace action mirrors, and destructive local changes require explicit user intent and the owning tool/command confirmation.',
+  '- Routines run in this serial conversation unless explicitly promoted to a connected schedule. Do not create hidden Agent jobs or local scheduler jobs.',
+  '- Do not delegate planning, research, operations, knowledge, memory, configuration, approvals, observability, or ordinary assistant work.',
+  '- For explicit build, implement, fix, patch, or review requests, preserve the full original ask and use the public shared-session/build-delegation route. If that route is unavailable, report the missing route instead of pretending to perform the work locally.',
 ].join('\n');
 
 function joinPromptParts(...parts: Array<string | null | undefined>): string {

package/src/runtime/connected-host-auth.ts

@@ -20,6 +20,22 @@ export function connectedHostOperatorTokenPath(homeDirectory: string): string {
 }
 
 export function readConnectedHostOperatorToken(homeDirectory: string): ConnectedHostOperatorToken {
+  const connectedHostEnvToken = process.env.GOODVIBES_CONNECTED_HOST_TOKEN?.trim();
+  if (connectedHostEnvToken) {
+    return {
+      path: 'env:GOODVIBES_CONNECTED_HOST_TOKEN',
+      present: true,
+      token: connectedHostEnvToken,
+    };
+  }
+  const legacyEnvToken = process.env.GOODVIBES_DAEMON_TOKEN?.trim();
+  if (legacyEnvToken) {
+    return {
+      path: 'env:GOODVIBES_DAEMON_TOKEN',
+      present: true,
+      token: legacyEnvToken,
+    };
+  }
   const path = connectedHostOperatorTokenPath(homeDirectory);
   if (!existsSync(path)) return { path, present: false, token: null };
   try {

package/src/tools/agent-analysis-registry-policy.ts

@@ -82,11 +82,7 @@ export function validateRegistryToolInvocationForAgentPolicy(args: RegistryToolA
 }
 
 function narrowAnalyzeToolDefinitionForAgentPolicy(tool: Tool): void {
-  tool.definition.description = [
-    'Run local, static project analysis for GoodVibes Agent.',
-    'npm registry upgrade checks and hidden secondary LLM diff analysis are disabled in the main conversation.',
-    'Delegate package-upgrade and review workflows to GoodVibes TUI when they become build/fix/review work.',
-  ].join(' ');
+  tool.definition.description = 'Run local, static project analysis for GoodVibes Agent.';
   tool.definition.sideEffects = ['read_fs'];
 
   const properties = tool.definition.parameters.properties;
@@ -101,10 +97,7 @@ function narrowAnalyzeToolDefinitionForAgentPolicy(tool: Tool): void {
 }
 
 function narrowRegistryToolDefinitionForAgentPolicy(tool: Tool): void {
-  tool.definition.description = [
-    'Discover and preview GoodVibes Agent skills, agents, and tools.',
-    'Full content materialization and arbitrary .goodvibes file reads are disabled in the main conversation.',
-  ].join(' ');
+  tool.definition.description = 'Discover and preview GoodVibes Agent registry entries.';
   tool.definition.sideEffects = ['read_fs'];
 
   const properties = tool.definition.parameters.properties;

package/src/tools/agent-channel-send-tool.ts

@@ -41,13 +41,7 @@ export function createAgentChannelSendTool(
   return {
     definition: {
       name: 'agent_channel_send',
-      description: [
-        'Send one explicitly confirmed message through a configured GoodVibes Agent delivery target from the main conversation.',
-        'Use only when the user explicitly asks Agent to send, message, alert, or notify a channel target.',
-        'Exactly one target must be supplied: channel, route, webhook, or link.',
-        'This tool does not create channel routes, authorize accounts, manage connected-host hosting, use default knowledge, use non-Agent knowledge segments, create separate Agent jobs, run delegated review, or invoke arbitrary routes.',
-        'Set confirm:true only for an explicit user request. Otherwise return the preview/confirmation error.',
-      ].join(' '),
+      description: 'Send one confirmed message through one configured Agent target.',
       parameters: {
         type: 'object',
         properties: {
@@ -61,7 +55,7 @@ export function createAgentChannelSendTool(
           },
           channel: {
             type: 'string',
-            description: 'Optional channel target surface[:route[:label]], such as slack:ops:Ops or telephony:+15551234567. Use exactly one target field.',
+            description: 'Optional channel target. Use exactly one target field.',
           },
           route: {
             type: 'string',
@@ -77,7 +71,7 @@ export function createAgentChannelSendTool(
           },
           confirm: {
             type: 'boolean',
-            description: 'Required true only when the user explicitly asked for this exact channel delivery.',
+            description: 'Required true for confirmed delivery.',
           },
           explicitUserRequest: {
             type: 'string',

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

@@ -7,11 +7,7 @@ const CONTEXT_TOOL_DENIAL = [
 ].join(' ');
 
 export function wrapBlockedContextToolForAgentPolicy(tool: Tool): void {
-  tool.definition.description = [
-    '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, non-Agent knowledge segments, and non-Agent runtime assumptions are not Agent fallbacks.',
-  ].join(' ');
+  tool.definition.description = 'Blocked in GoodVibes Agent: non-Agent runtime context.';
   tool.definition.sideEffects = [];
   tool.definition.parameters = {
     type: 'object',

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

@@ -82,10 +82,7 @@ export function normalizeFindToolInvocationForAgentPolicy(args: FindToolArgs): F
 }
 
 function narrowFindToolDefinitionForAgentPolicy(tool: Tool): void {
-  tool.definition.description = [
-    'Search the project for GoodVibes Agent using serial, gitignore-respecting read-only queries.',
-    'Hidden-file scans, symlink traversal, gitignore bypass, broad previews, full symbol dumps, and parallel search are disabled in the main conversation.',
-  ].join(' ');
+  tool.definition.description = 'Search project files with serial, gitignore-respecting read-only queries.';
   tool.definition.sideEffects = ['read_fs'];
   tool.definition.concurrency = 'serial';