@pellux/goodvibes-agent 1.1.6 → 1.1.7

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 Product-facing release notes for GoodVibes Agent.
 
+## 1.1.7 - 2026-06-05
+
+- Hardened the Agent model tool surface so goodvibes_context routes to the Agent harness instead of dead-ending.
+- Added tool execution and permission safety guards so registered model tools return structured failures instead of aborting turns.
+- Added registered-tool smoke coverage for the Agent-guarded platform tool roster.
+
 ## 1.1.6 - 2026-06-05
 
 - Fixed Import GoodVibes settings so it also imports active and pending provider subscriptions from the GoodVibes TUI user store into Agent-owned subscription state.

package/dist/package/main.js

@@ -450372,23 +450372,6 @@ function createSchema2(db) {
   `);
   db.run(`CREATE INDEX IF NOT EXISTS idx_knowledge_schedules_job_id ON knowledge_schedules(job_id)`);
 }
-function getKnowledgeSchemaStatements() {
-  const statements = [];
-  createSchema2({
-    run(sql) {
-      const normalized = sql.trim();
-      if (normalized.length > 0)
-        statements.push(normalized);
-    }
-  });
-  return statements;
-}
-function renderKnowledgeSchemaSql() {
-  return `${getKnowledgeSchemaStatements().map((statement) => statement.endsWith(";") ? statement : `${statement};`).join(`
-
-`)}
-`;
-}
 function rowObject(columns, values2) {
   return Object.fromEntries(columns.map((column, index) => [column, values2[index]]));
 }
@@ -763671,9 +763654,6 @@ var init_ingest = __esm(() => {
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/browser-history/index.js
 var init_browser_history = __esm(() => {
   init_ingest();
-  init_discover();
-  init_readers();
-  init_paths2();
 });
 
 // node_modules/graphql/jsutils/devAssert.mjs
@@ -781313,7 +781293,6 @@ var init_semantic = __esm(() => {
   init_llm();
   init_gap_repair();
   init_service4();
-  init_self_improvement();
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/home-graph/helpers.js
@@ -785282,40 +785261,8 @@ var init_map_view = __esm(() => {
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/home-graph/types.js
-var HOME_GRAPH_NODE_KINDS, HOME_GRAPH_RELATIONS, HOME_GRAPH_CAPABILITIES;
+var HOME_GRAPH_CAPABILITIES;
 var init_types15 = __esm(() => {
-  HOME_GRAPH_NODE_KINDS = [
-    "ha_home",
-    "ha_entity",
-    "ha_device",
-    "ha_area",
-    "ha_automation",
-    "ha_script",
-    "ha_scene",
-    "ha_label",
-    "ha_integration",
-    "ha_room",
-    "ha_device_passport",
-    "ha_maintenance_item",
-    "ha_troubleshooting_case",
-    "ha_purchase",
-    "ha_network_node"
-  ];
-  HOME_GRAPH_RELATIONS = [
-    "controls",
-    "located_in",
-    "belongs_to_device",
-    "has_manual",
-    "has_receipt",
-    "has_warranty",
-    "has_issue",
-    "fixed_by",
-    "uses_battery",
-    "connected_via",
-    "part_of_network",
-    "mentioned_by",
-    "source_for"
-  ];
   HOME_GRAPH_CAPABILITIES = [
     "knowledge-space-isolation",
     "snapshot-sync",
@@ -786722,7 +786669,6 @@ var init_service5 = __esm(() => {
 var init_home_graph = __esm(() => {
   init_service5();
   init_extension();
-  init_types15();
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/store-refinement.js
@@ -789050,14 +788996,10 @@ var init_service6 = __esm(() => {
 var init_project_planning = __esm(() => {
   init_service6();
   init_helpers3();
-  init_readiness();
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/persistence.js
-var init_persistence = __esm(() => {
-  init_store_schema();
-  init_store_load();
-});
+var init_persistence = () => {};
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/knowledge/projections.js
 class KnowledgeProjectionService {
@@ -792565,21 +792507,21 @@ var init_service7 = __esm(() => {
 var exports_knowledge = {};
 __export(exports_knowledge, {
   withKnowledgeSpace: () => withKnowledgeSpace,
-  uniqKnowledgeValues: () => uniq2,
-  stabilizeKnowledgeText: () => stableText,
-  runKnowledgeSemanticSelfImprovement: () => runKnowledgeSemanticSelfImprovement,
+  uniqKnowledgeValues: () => uniq3,
+  stabilizeKnowledgeText: () => stableText2,
+  runKnowledgeSemanticSelfImprovement: () => runKnowledgeSemanticSelfImprovement2,
   resolveProjectPlanningSpace: () => resolveProjectPlanningSpace,
-  resolveKnowledgeDbPathFromControlPlaneDir: () => resolveKnowledgeDbPathFromControlPlaneDir,
+  resolveKnowledgeDbPathFromControlPlaneDir: () => resolveKnowledgeDbPathFromControlPlaneDir2,
   renderPacket: () => renderPacket,
   renderKnowledgeSchemaSql: () => renderKnowledgeSchemaSql,
   renderKnowledgeMap: () => renderKnowledgeMap,
   readKnowledgeSearchText: () => readKnowledgeSearchText,
-  readBrowserKnowledgeProfile: () => readBrowserKnowledgeProfile,
+  readBrowserKnowledgeProfile: () => readBrowserKnowledgeProfile2,
   projectPlanningSourceId: () => projectPlanningSourceId,
   projectPlanningProjectIdFromPath: () => projectPlanningProjectIdFromPath,
   projectPlanningCanonicalUri: () => projectPlanningCanonicalUri,
   projectKnowledgeSpaceId: () => projectKnowledgeSpaceId,
-  parseKnowledgeJsonValue: () => parseJsonValue,
+  parseKnowledgeJsonValue: () => parseJsonValue2,
   normalizeProjectId: () => normalizeProjectId,
   normalizeKnowledgeSpaceId: () => normalizeKnowledgeSpaceId,
   normalizeHomeAssistantInstallationId: () => normalizeHomeAssistantInstallationId,
@@ -792587,12 +792529,12 @@ __export(exports_knowledge, {
   materializeGeneratedKnowledgeProjection: () => materializeGeneratedKnowledgeProjection,
   looksLikeRawPdfPayload: () => looksLikeRawPdfPayload,
   looksBinaryLikeText: () => looksBinaryLikeText,
-  loadKnowledgeStoreSnapshot: () => loadKnowledgeStoreSnapshot,
+  loadKnowledgeStoreSnapshot: () => loadKnowledgeStoreSnapshot2,
   listGeneratedKnowledgePages: () => listGeneratedKnowledgePages,
-  listBrowserKinds: () => listBrowserKinds,
+  listBrowserKinds: () => listBrowserKinds2,
   knowledgeSpaceMetadata: () => knowledgeSpaceMetadata,
   knowledgePageSourceWeight: () => knowledgePageSourceWeight,
-  knowledgeNowMs: () => nowMs,
+  knowledgeNowMs: () => nowMs2,
   knowledgeExtractionNeedsRefresh: () => knowledgeExtractionNeedsRefresh,
   isUsefulKnowledgePageSourceCandidate: () => isUsefulKnowledgePageSourceCandidate,
   isUsefulKnowledgePageSource: () => isUsefulKnowledgePageSource,
@@ -792612,12 +792554,12 @@ __export(exports_knowledge, {
   generatedKnowledgeSourceId: () => generatedKnowledgeSourceId,
   generatedKnowledgeCanonicalUri: () => generatedKnowledgeCanonicalUri,
   extractKnowledgeArtifact: () => extractKnowledgeArtifact,
-  evaluateProjectPlanningReadiness: () => evaluateProjectPlanningReadiness,
-  discoverBrowserKnowledgeProfiles: () => discoverBrowserKnowledgeProfiles,
+  evaluateProjectPlanningReadiness: () => evaluateProjectPlanningReadiness2,
+  discoverBrowserKnowledgeProfiles: () => discoverBrowserKnowledgeProfiles2,
   createWebKnowledgeGapRepairer: () => createWebKnowledgeGapRepairer,
   createProviderBackedKnowledgeSemanticLlm: () => createProviderBackedKnowledgeSemanticLlm,
   createMemoryApi: () => createMemoryApi,
-  createKnowledgeSchema: () => createSchema2,
+  createKnowledgeSchema: () => createSchema3,
   createKnowledgeApi: () => createKnowledgeApi,
   createDefaultKnowledgeConnectorRegistry: () => createDefaultKnowledgeConnectorRegistry,
   compareKnowledgePageSources: () => compareKnowledgePageSources,
@@ -795056,7 +794998,7 @@ var init_delivery_manager = __esm(() => {
 });
 
 // node_modules/@pellux/goodvibes-sdk/dist/platform/automation/scheduler-capacity.js
-function computeSchedulerCapacity(slotsTotal, runs, nowMs2 = Date.now()) {
+function computeSchedulerCapacity(slotsTotal, runs, nowMs3 = Date.now()) {
   let slotsInUse = 0;
   const queuedRuns = [];
   for (const run7 of runs) {
@@ -795066,7 +795008,7 @@ function computeSchedulerCapacity(slotsTotal, runs, nowMs2 = Date.now()) {
       queuedRuns.push(run7);
   }
   const queueDepth = queuedRuns.length;
-  const oldestQueuedAgeMs = queueDepth > 0 ? nowMs2 - Math.min(...queuedRuns.map((r6) => r6.queuedAt)) : null;
+  const oldestQueuedAgeMs = queueDepth > 0 ? nowMs3 - Math.min(...queuedRuns.map((r6) => r6.queuedAt)) : null;
   return { slotsTotal, slotsInUse, queueDepth, oldestQueuedAgeMs };
 }
 
@@ -817092,7 +817034,7 @@ var createStyledCell = (char, overrides = {}) => ({
 // src/version.ts
 import { readFileSync } from "fs";
 import { join } from "path";
-var _version = "1.1.6";
+var _version = "1.1.7";
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, "..", "package.json"), "utf-8"));
   _version = typeof pkg.version === "string" ? pkg.version : _version;
@@ -839605,7 +839547,7 @@ var WORK_PLAN_STATUSES = [
   "failed",
   "cancelled"
 ];
-function nowMs2() {
+function nowMs3() {
   return Date.now();
 }
 function isObject4(value) {
@@ -839711,7 +839653,7 @@ class WorkPlanStore {
     if (!normalizedTitle)
       throw new Error("Work plan item title is required.");
     const plan = this.readPlan();
-    const time4 = nowMs2();
+    const time4 = nowMs3();
     const item = {
       id: createItemId(),
       title: normalizedTitle,
@@ -839735,7 +839677,7 @@ class WorkPlanStore {
   updateItem(idOrPrefix, patch2) {
     const plan = this.readPlan();
     const item = this.resolveItem(plan, idOrPrefix);
-    const time4 = nowMs2();
+    const time4 = nowMs3();
     const nextStatus = patch2.status ?? item.status;
     const next = this.pruneItem({
       ...item,
@@ -839768,7 +839710,7 @@ class WorkPlanStore {
   removeItem(idOrPrefix) {
     const plan = this.readPlan();
     const item = this.resolveItem(plan, idOrPrefix);
-    const time4 = nowMs2();
+    const time4 = nowMs3();
     const remaining = plan.items.filter((candidate) => candidate.id !== item.id);
     this.writePlan({
       ...plan,
@@ -839788,7 +839730,7 @@ class WorkPlanStore {
       ...plan,
       items: remaining,
       activeItemId: remaining[0]?.id,
-      updatedAt: nowMs2()
+      updatedAt: nowMs3()
     });
     return removed;
   }
@@ -839827,7 +839769,7 @@ class WorkPlanStore {
     const parsed = JSON.parse(raw);
     if (!isObject4(parsed))
       return this.createEmptyPlan();
-    const time4 = nowMs2();
+    const time4 = nowMs3();
     const createdAt = typeof parsed.createdAt === "number" ? parsed.createdAt : time4;
     const updatedAt = typeof parsed.updatedAt === "number" ? parsed.updatedAt : createdAt;
     const items = Array.isArray(parsed.items) ? parsed.items.map((item) => normalizeItem(item, createdAt)).filter((item) => item !== null) : [];
@@ -839846,7 +839788,7 @@ class WorkPlanStore {
     };
   }
   createEmptyPlan() {
-    const time4 = nowMs2();
+    const time4 = nowMs3();
     return {
       id: createPlanId(this.options.projectId, this.options.projectRoot),
       projectId: this.options.projectId,
@@ -840631,20 +840573,132 @@ function isRecord17(value) {
 }
 
 // src/tools/agent-context-policy.ts
-var CONTEXT_TOOL_DENIAL = [
-  "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(" ");
-function wrapBlockedContextToolForAgentPolicy(tool2) {
-  tool2.definition.description = "Blocked in GoodVibes Agent: non-Agent runtime context.";
+var AGENT_CONTEXT_TOOL_MODES = [
+  "summary",
+  "capabilities",
+  "modes",
+  "tools",
+  "tool",
+  "settings",
+  "setting",
+  "commands",
+  "command",
+  "workspace",
+  "status"
+];
+var CONTEXT_TOOL_FALLBACK = {
+  runtime: "GoodVibes Agent",
+  preferredTool: "agent_harness",
+  routes: {
+    summary: 'agent_harness mode:"summary"',
+    capabilities: 'agent_harness mode:"summary" includeParameters:true',
+    tools: 'agent_harness mode:"tools"',
+    tool: 'agent_harness mode:"tool"',
+    settings: 'agent_harness mode:"settings"',
+    commands: 'agent_harness mode:"commands"',
+    workspace: 'agent_harness mode:"workspace"',
+    status: 'agent_harness mode:"connected_host_status"'
+  }
+};
+function wrapAgentContextToolForAgentPolicy(tool2, registry5) {
+  tool2.definition.description = "Inspect GoodVibes Agent harness capabilities.";
   tool2.definition.sideEffects = [];
   tool2.definition.parameters = {
     type: "object",
-    properties: {},
+    properties: {
+      mode: { type: "string", enum: [...AGENT_CONTEXT_TOOL_MODES] },
+      query: { type: "string" },
+      target: { type: "string" },
+      toolName: { type: "string" },
+      command: { type: "string" },
+      commandName: { type: "string" },
+      key: { type: "string" },
+      category: { type: "string" },
+      prefix: { type: "string" },
+      includeHidden: { type: "boolean" },
+      includeParameters: { type: "boolean" },
+      limit: { type: "number" }
+    },
     additionalProperties: false
   };
-  tool2.execute = async () => ({ success: false, error: CONTEXT_TOOL_DENIAL });
+  tool2.execute = async (rawArgs) => {
+    const args2 = rawArgs;
+    const mode = readAgentContextMode(args2.mode);
+    const harnessMode = agentContextModeToHarnessMode(mode);
+    const harnessTool = registry5?.list().find((entry) => entry.definition.name === "agent_harness");
+    if (!harnessTool) {
+      return ok3({
+        ...CONTEXT_TOOL_FALLBACK,
+        status: "agent_harness_not_registered_yet",
+        requestedMode: mode,
+        route: `agent_harness mode:"${harnessMode}"`
+      });
+    }
+    const harnessArgs = {
+      mode: harnessMode,
+      query: args2.query,
+      target: args2.target,
+      toolName: args2.toolName,
+      command: args2.command,
+      commandName: args2.commandName,
+      key: args2.key,
+      category: args2.category,
+      prefix: args2.prefix,
+      includeHidden: args2.includeHidden,
+      includeParameters: mode === "capabilities" ? true : args2.includeParameters,
+      limit: args2.limit
+    };
+    const result2 = await harnessTool.execute(dropUndefined(harnessArgs));
+    if (!result2.success)
+      return result2;
+    return ok3({
+      source: "agent_harness",
+      requestedMode: mode,
+      route: `agent_harness mode:"${harnessMode}"`,
+      result: parseToolOutput2(result2.output)
+    });
+  };
+}
+function readAgentContextMode(value) {
+  return typeof value === "string" && AGENT_CONTEXT_TOOL_MODES.includes(value) ? value : "summary";
+}
+function agentContextModeToHarnessMode(mode) {
+  if (mode === "capabilities")
+    return "summary";
+  if (mode === "modes")
+    return "modes";
+  if (mode === "tools")
+    return "tools";
+  if (mode === "tool")
+    return "tool";
+  if (mode === "settings")
+    return "settings";
+  if (mode === "setting")
+    return "get_setting";
+  if (mode === "commands")
+    return "commands";
+  if (mode === "command")
+    return "command";
+  if (mode === "workspace")
+    return "workspace";
+  if (mode === "status")
+    return "connected_host_status";
+  return "summary";
+}
+function dropUndefined(value) {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+function parseToolOutput2(value) {
+  if (typeof value !== "string")
+    return value ?? null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function ok3(value) {
+  return { success: true, output: JSON.stringify(value, null, 2) };
 }
 
 // src/tools/agent-find-policy.ts
@@ -841115,7 +841169,7 @@ function installAgentToolPolicyGuard(registry5, options = {}) {
     } else if (tool2.definition.name === "state") {
       wrapStateToolForAgentPolicy(tool2);
     } else if (tool2.definition.name === "goodvibes_context") {
-      wrapBlockedContextToolForAgentPolicy(tool2);
+      wrapAgentContextToolForAgentPolicy(tool2, registry5);
     } else if (tool2.definition.name === "goodvibes_settings") {
       wrapBlockedSettingsToolForAgentPolicy(tool2);
     } else if (tool2.definition.name === "inspect") {
@@ -848607,6 +848661,119 @@ function compactRegisteredToolDefinitions(toolRegistry) {
   }
 }
 
+// src/tools/tool-execution-safety.ts
+var TOOL_SAFETY_MARKER = Symbol.for("goodvibes-agent.tool-execution-safety-wrapped");
+var REGISTRY_SAFETY_MARKER = Symbol.for("goodvibes-agent.tool-registry-safety-installed");
+function installToolExecutionSafetyGuard(registry5) {
+  const marked = registry5;
+  if (marked[REGISTRY_SAFETY_MARKER])
+    return;
+  marked[REGISTRY_SAFETY_MARKER] = true;
+  for (const tool2 of registry5.list())
+    wrapToolExecutionSafety(tool2);
+  const originalRegister = registry5.register.bind(registry5);
+  registry5.register = (tool2) => {
+    wrapToolExecutionSafety(tool2);
+    originalRegister(tool2);
+  };
+}
+function wrapToolExecutionSafety(tool2) {
+  const marked = tool2;
+  if (marked[TOOL_SAFETY_MARKER])
+    return;
+  marked[TOOL_SAFETY_MARKER] = true;
+  const originalExecute = tool2.execute.bind(tool2);
+  tool2.execute = async (args2) => {
+    try {
+      return await originalExecute(args2);
+    } catch (error51) {
+      return {
+        success: false,
+        error: summarizeError(error51)
+      };
+    }
+  };
+}
+
+// src/runtime/tool-permission-safety.ts
+var SAFETY_MARKER = Symbol.for("goodvibes-agent.permission-safety-installed");
+var READ_TOOL_NAMES = new Set([
+  "read",
+  "find",
+  "fetch",
+  "analyze",
+  "inspect",
+  "state",
+  "registry",
+  "goodvibes_context",
+  "agent_harness",
+  "agent_knowledge",
+  "agent_operator_briefing"
+]);
+var WRITE_TOOL_NAMES = new Set([
+  "write",
+  "edit",
+  "goodvibes_settings",
+  "agent_knowledge_ingest",
+  "agent_local_registry",
+  "agent_work_plan"
+]);
+var EXECUTE_TOOL_NAMES = new Set(["exec", "repl"]);
+function installPermissionManagerSafetyGuard(manager5) {
+  const marked = manager5;
+  if (marked[SAFETY_MARKER])
+    return;
+  marked[SAFETY_MARKER] = true;
+  const originalGetCategory = manager5.getCategory.bind(manager5);
+  const originalCheck = manager5.check.bind(manager5);
+  const originalCheckDetailed = manager5.checkDetailed?.bind(manager5);
+  manager5.getCategory = (toolName, args2 = {}) => {
+    try {
+      return originalGetCategory(toolName, args2);
+    } catch {
+      return fallbackPermissionCategory(toolName);
+    }
+  };
+  manager5.check = async (toolName, args2) => {
+    try {
+      return await originalCheck(toolName, args2);
+    } catch {
+      return fallbackPermissionCategory(toolName) === "read";
+    }
+  };
+  if (originalCheckDetailed) {
+    manager5.checkDetailed = async (toolName, args2) => {
+      try {
+        return await originalCheckDetailed(toolName, args2);
+      } catch (error51) {
+        const category = fallbackPermissionCategory(toolName);
+        const approved = category === "read";
+        return {
+          approved,
+          persisted: false,
+          sourceLayer: "runtime_mode",
+          reasonCode: approved ? "config_allow" : "config_deny",
+          analysis: {
+            classification: "generic",
+            riskLevel: category === "read" ? "low" : "high",
+            summary: `Permission fallback for ${toolName}: ${summarizeError(error51)}`,
+            reasons: ["permission-manager-exception"]
+          }
+        };
+      }
+    };
+  }
+}
+function fallbackPermissionCategory(toolName) {
+  if (READ_TOOL_NAMES.has(toolName))
+    return "read";
+  if (WRITE_TOOL_NAMES.has(toolName))
+    return "write";
+  if (EXECUTE_TOOL_NAMES.has(toolName))
+    return "execute";
+  return "delegate";
+}
+
 // src/runtime/agent-runtime-events.ts
 var AGENT_STATUS_INTERVAL_MS2 = 30000;
 function withRouter2(getSystemMessageRouter, action2) {
@@ -848863,6 +849030,7 @@ async function initializeBootstrapCore(stdout, options, getControlPlaneRecentEve
   installAgentToolPolicyGuard(toolRegistry, {
     getLastUserMessage: () => conversation.getLastUserMessage()
   });
+  installToolExecutionSafetyGuard(toolRegistry);
   compactRegisteredToolDefinitions(toolRegistry);
   services.agentOrchestrator.setDependencies({
     surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
@@ -849001,6 +849169,7 @@ async function initializeBootstrapCore(stdout, options, getControlPlaneRecentEve
     sessionId: runtimeSessionIdRef.value,
     localPrompt: permissionPromptRef.requestPermission
   }), createPermissionConfigReader(configManager), policyRuntimeState, services.hookDispatcher, featureFlags);
+  installPermissionManagerSafetyGuard(permissionManager);
   await hookWorkbench.loadAndApplyManagedHooks();
   const runtime2 = {
     model: configManager.get("provider.model"),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "1.1.6",
+  "version": "1.1.7",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/runtime/bootstrap-core.ts

@@ -41,6 +41,8 @@ import { registerAgentReminderScheduleTool } from '../tools/agent-reminder-sched
 import { getTerminalSize } from '../shell/terminal-size.ts';
 import { registerAgentWorkPlanTool } from '../tools/agent-work-plan-tool.ts';
 import { compactRegisteredToolDefinitions } from '../tools/tool-definition-compaction.ts';
+import { installToolExecutionSafetyGuard } from '../tools/tool-execution-safety.ts';
+import { installPermissionManagerSafetyGuard } from './tool-permission-safety.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { registerAgentRuntimeEvents } from './agent-runtime-events.ts';
 
@@ -251,6 +253,7 @@ export async function initializeBootstrapCore(
   installAgentToolPolicyGuard(toolRegistry, {
     getLastUserMessage: () => conversation.getLastUserMessage(),
   });
+  installToolExecutionSafetyGuard(toolRegistry);
   compactRegisteredToolDefinitions(toolRegistry);
   services.agentOrchestrator.setDependencies({
     surfaceRoot: GOODVIBES_AGENT_SURFACE_ROOT,
@@ -432,6 +435,7 @@ export async function initializeBootstrapCore(
     services.hookDispatcher,
     featureFlags,
   );
+  installPermissionManagerSafetyGuard(permissionManager);
   await hookWorkbench.loadAndApplyManagedHooks();
 
   const runtime: MutableRuntimeState = {

package/src/runtime/tool-permission-safety.ts

@@ -0,0 +1,93 @@
+import type { PermissionCategory, PermissionCheckResult } from '@pellux/goodvibes-sdk/platform/permissions';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+type PermissionManagerLike = {
+  check(toolName: string, args: Record<string, unknown>): Promise<boolean>;
+  checkDetailed?: (toolName: string, args: Record<string, unknown>) => Promise<PermissionCheckResult>;
+  getCategory(toolName: string, args?: Record<string, unknown>): PermissionCategory;
+};
+
+const SAFETY_MARKER = Symbol.for('goodvibes-agent.permission-safety-installed');
+
+const READ_TOOL_NAMES = new Set([
+  'read',
+  'find',
+  'fetch',
+  'analyze',
+  'inspect',
+  'state',
+  'registry',
+  'goodvibes_context',
+  'agent_harness',
+  'agent_knowledge',
+  'agent_operator_briefing',
+]);
+
+const WRITE_TOOL_NAMES = new Set([
+  'write',
+  'edit',
+  'goodvibes_settings',
+  'agent_knowledge_ingest',
+  'agent_local_registry',
+  'agent_work_plan',
+]);
+
+const EXECUTE_TOOL_NAMES = new Set(['exec', 'repl']);
+
+type MarkedPermissionManager = PermissionManagerLike & { [SAFETY_MARKER]?: true };
+
+export function installPermissionManagerSafetyGuard(manager: PermissionManagerLike): void {
+  const marked = manager as MarkedPermissionManager;
+  if (marked[SAFETY_MARKER]) return;
+  marked[SAFETY_MARKER] = true;
+
+  const originalGetCategory = manager.getCategory.bind(manager);
+  const originalCheck = manager.check.bind(manager);
+  const originalCheckDetailed = manager.checkDetailed?.bind(manager);
+
+  manager.getCategory = (toolName, args = {}) => {
+    try {
+      return originalGetCategory(toolName, args);
+    } catch {
+      return fallbackPermissionCategory(toolName);
+    }
+  };
+
+  manager.check = async (toolName, args) => {
+    try {
+      return await originalCheck(toolName, args);
+    } catch {
+      return fallbackPermissionCategory(toolName) === 'read';
+    }
+  };
+
+  if (originalCheckDetailed) {
+    manager.checkDetailed = async (toolName, args) => {
+      try {
+        return await originalCheckDetailed(toolName, args);
+      } catch (error) {
+        const category = fallbackPermissionCategory(toolName);
+        const approved = category === 'read';
+        return {
+          approved,
+          persisted: false,
+          sourceLayer: 'runtime_mode',
+          reasonCode: approved ? 'config_allow' : 'config_deny',
+          analysis: {
+            classification: 'generic',
+            riskLevel: category === 'read' ? 'low' : 'high',
+            summary: `Permission fallback for ${toolName}: ${summarizeError(error)}`,
+            reasons: ['permission-manager-exception'],
+          },
+        };
+      }
+    };
+  }
+}
+
+export function fallbackPermissionCategory(toolName: string): PermissionCategory {
+  if (READ_TOOL_NAMES.has(toolName)) return 'read';
+  if (WRITE_TOOL_NAMES.has(toolName)) return 'write';
+  if (EXECUTE_TOOL_NAMES.has(toolName)) return 'execute';
+  return 'delegate';
+}

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

@@ -1,20 +1,147 @@
 import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 
-const CONTEXT_TOOL_DENIAL = [
-  '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(' ');
+const AGENT_CONTEXT_TOOL_MODES = [
+  'summary',
+  'capabilities',
+  'modes',
+  'tools',
+  'tool',
+  'settings',
+  'setting',
+  'commands',
+  'command',
+  'workspace',
+  'status',
+] as const;
 
-export function wrapBlockedContextToolForAgentPolicy(tool: Tool): void {
-  tool.definition.description = 'Blocked in GoodVibes Agent: non-Agent runtime context.';
+type AgentContextMode = typeof AGENT_CONTEXT_TOOL_MODES[number];
+
+type AgentContextArgs = {
+  readonly mode?: unknown;
+  readonly query?: unknown;
+  readonly target?: unknown;
+  readonly toolName?: unknown;
+  readonly command?: unknown;
+  readonly commandName?: unknown;
+  readonly key?: unknown;
+  readonly category?: unknown;
+  readonly prefix?: unknown;
+  readonly includeHidden?: unknown;
+  readonly includeParameters?: unknown;
+  readonly limit?: unknown;
+};
+
+const CONTEXT_TOOL_FALLBACK = {
+  runtime: 'GoodVibes Agent',
+  preferredTool: 'agent_harness',
+  routes: {
+    summary: 'agent_harness mode:"summary"',
+    capabilities: 'agent_harness mode:"summary" includeParameters:true',
+    tools: 'agent_harness mode:"tools"',
+    tool: 'agent_harness mode:"tool"',
+    settings: 'agent_harness mode:"settings"',
+    commands: 'agent_harness mode:"commands"',
+    workspace: 'agent_harness mode:"workspace"',
+    status: 'agent_harness mode:"connected_host_status"',
+  },
+};
+
+export function wrapAgentContextToolForAgentPolicy(tool: Tool, registry?: ToolRegistry): void {
+  tool.definition.description = 'Inspect GoodVibes Agent harness capabilities.';
   tool.definition.sideEffects = [];
   tool.definition.parameters = {
     type: 'object',
-    properties: {},
+    properties: {
+      mode: { type: 'string', enum: [...AGENT_CONTEXT_TOOL_MODES] },
+      query: { type: 'string' },
+      target: { type: 'string' },
+      toolName: { type: 'string' },
+      command: { type: 'string' },
+      commandName: { type: 'string' },
+      key: { type: 'string' },
+      category: { type: 'string' },
+      prefix: { type: 'string' },
+      includeHidden: { type: 'boolean' },
+      includeParameters: { type: 'boolean' },
+      limit: { type: 'number' },
+    },
     additionalProperties: false,
   };
-  tool.execute = async () => ({ success: false, error: CONTEXT_TOOL_DENIAL });
+  tool.execute = async (rawArgs) => {
+    const args = rawArgs as AgentContextArgs;
+    const mode = readAgentContextMode(args.mode);
+    const harnessMode = agentContextModeToHarnessMode(mode);
+    const harnessTool = registry?.list().find((entry) => entry.definition.name === 'agent_harness');
+    if (!harnessTool) {
+      return ok({
+        ...CONTEXT_TOOL_FALLBACK,
+        status: 'agent_harness_not_registered_yet',
+        requestedMode: mode,
+        route: `agent_harness mode:"${harnessMode}"`,
+      });
+    }
+
+    const harnessArgs = {
+      mode: harnessMode,
+      query: args.query,
+      target: args.target,
+      toolName: args.toolName,
+      command: args.command,
+      commandName: args.commandName,
+      key: args.key,
+      category: args.category,
+      prefix: args.prefix,
+      includeHidden: args.includeHidden,
+      includeParameters: mode === 'capabilities' ? true : args.includeParameters,
+      limit: args.limit,
+    };
+    const result = await harnessTool.execute(dropUndefined(harnessArgs));
+    if (!result.success) return result;
+    return ok({
+      source: 'agent_harness',
+      requestedMode: mode,
+      route: `agent_harness mode:"${harnessMode}"`,
+      result: parseToolOutput(result.output),
+    });
+  };
+}
+
+export const AGENT_CONTEXT_TOOL_COMPATIBILITY_MODES = AGENT_CONTEXT_TOOL_MODES;
+
+function readAgentContextMode(value: unknown): AgentContextMode {
+  return typeof value === 'string' && AGENT_CONTEXT_TOOL_MODES.includes(value as AgentContextMode)
+    ? value as AgentContextMode
+    : 'summary';
 }
 
-export const AGENT_CONTEXT_TOOL_DENIAL_MESSAGE = CONTEXT_TOOL_DENIAL;
+function agentContextModeToHarnessMode(mode: AgentContextMode): string {
+  if (mode === 'capabilities') return 'summary';
+  if (mode === 'modes') return 'modes';
+  if (mode === 'tools') return 'tools';
+  if (mode === 'tool') return 'tool';
+  if (mode === 'settings') return 'settings';
+  if (mode === 'setting') return 'get_setting';
+  if (mode === 'commands') return 'commands';
+  if (mode === 'command') return 'command';
+  if (mode === 'workspace') return 'workspace';
+  if (mode === 'status') return 'connected_host_status';
+  return 'summary';
+}
+
+function dropUndefined<T extends Record<string, unknown>>(value: T): Record<string, unknown> {
+  return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
+}
+
+function parseToolOutput(value: unknown): unknown {
+  if (typeof value !== 'string') return value ?? null;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+function ok(value: unknown): { readonly success: true; readonly output: string } {
+  return { success: true, output: JSON.stringify(value, null, 2) };
+}

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

@@ -5,7 +5,7 @@ import {
   wrapRegistryToolForAgentPolicy,
 } from './agent-analysis-registry-policy.ts';
 import {
-  wrapBlockedContextToolForAgentPolicy,
+  wrapAgentContextToolForAgentPolicy,
 } from './agent-context-policy.ts';
 import { wrapFindToolForAgentPolicy } from './agent-find-policy.ts';
 import { wrapReadToolForAgentPolicy } from './agent-read-policy.ts';
@@ -223,7 +223,7 @@ export function installAgentToolPolicyGuard(registry: ToolRegistry, options: Age
     } else if (tool.definition.name === 'state') {
       wrapStateToolForAgentPolicy(tool);
     } else if (tool.definition.name === 'goodvibes_context') {
-      wrapBlockedContextToolForAgentPolicy(tool);
+      wrapAgentContextToolForAgentPolicy(tool, registry);
     } else if (tool.definition.name === 'goodvibes_settings') {
       wrapBlockedSettingsToolForAgentPolicy(tool);
     } else if (tool.definition.name === 'inspect') {
@@ -538,8 +538,8 @@ export const AGENT_DURABLE_WORKFLOW_MUTATION_DENIAL_MESSAGE = DURABLE_WORKFLOW_M
 export const AGENT_CONTROL_MUTATION_DENIAL_MESSAGE = CONTROL_MUTATION_DENIAL;
 
 export {
-  AGENT_CONTEXT_TOOL_DENIAL_MESSAGE,
-  wrapBlockedContextToolForAgentPolicy,
+  AGENT_CONTEXT_TOOL_COMPATIBILITY_MODES,
+  wrapAgentContextToolForAgentPolicy,
 } from './agent-context-policy.ts';
 
 export {

package/src/tools/tool-execution-safety.ts

@@ -0,0 +1,41 @@
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
+import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+const TOOL_SAFETY_MARKER = Symbol.for('goodvibes-agent.tool-execution-safety-wrapped');
+const REGISTRY_SAFETY_MARKER = Symbol.for('goodvibes-agent.tool-registry-safety-installed');
+
+type MarkedTool = Tool & { [TOOL_SAFETY_MARKER]?: true };
+type MarkedRegistry = ToolRegistry & { [REGISTRY_SAFETY_MARKER]?: true };
+
+export function installToolExecutionSafetyGuard(registry: ToolRegistry): void {
+  const marked = registry as MarkedRegistry;
+  if (marked[REGISTRY_SAFETY_MARKER]) return;
+  marked[REGISTRY_SAFETY_MARKER] = true;
+
+  for (const tool of registry.list()) wrapToolExecutionSafety(tool);
+
+  const originalRegister = registry.register.bind(registry);
+  registry.register = (tool: Tool): void => {
+    wrapToolExecutionSafety(tool);
+    originalRegister(tool);
+  };
+}
+
+export function wrapToolExecutionSafety(tool: Tool): void {
+  const marked = tool as MarkedTool;
+  if (marked[TOOL_SAFETY_MARKER]) return;
+  marked[TOOL_SAFETY_MARKER] = true;
+
+  const originalExecute = tool.execute.bind(tool);
+  tool.execute = async (args) => {
+    try {
+      return await originalExecute(args);
+    } catch (error) {
+      return {
+        success: false,
+        error: summarizeError(error),
+      };
+    }
+  };
+}

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 = '1.1.6';
+let _version = '1.1.7';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;