principles-disciple 1.16.0 → 1.18.0

package/tests/core/pain.test.ts

@@ -107,13 +107,13 @@ describe('Pain Detection Module', () => {
       const missing = validatePainFlag({
         source: 'tool_failure',
         score: '70',
-        // missing time, reason, session_id, agent_id
+        // missing time, reason (session_id/agent_id are optional)
       });
 
       expect(missing).toContain('time');
       expect(missing).toContain('reason');
-      expect(missing).toContain('session_id');
-      expect(missing).toContain('agent_id');
+      expect(missing).not.toContain('session_id');
+      expect(missing).not.toContain('agent_id');
     });
 
     it('should report empty string fields as missing', () => {
@@ -126,7 +126,8 @@ describe('Pain Detection Module', () => {
         agent_id: 'main',
       });
 
-      expect(missing).toContain('session_id');
+      // session_id/agent_id are optional — empty values are acceptable
+      expect(missing).toEqual([]);
     });
   });
 });

package/tests/core/workspace-dir-service.test.ts

@@ -0,0 +1,68 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import * as os from 'os';
+import { resolveRequiredWorkspaceDir, resolveWorkspaceDir } from '../../src/core/workspace-dir-service.js';
+
+const homeDir = os.homedir();
+
+describe('workspace-dir-service', () => {
+  const logger = {
+    error: vi.fn(),
+    warn: vi.fn(),
+    info: vi.fn(),
+    debug: vi.fn(),
+  };
+
+  const api = {
+    runtime: {
+      agent: {
+        resolveAgentWorkspaceDir: vi.fn(),
+      },
+    },
+    config: {},
+    logger,
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    api.runtime.agent.resolveAgentWorkspaceDir.mockReturnValue('/resolved/workspace');
+  });
+
+  it('accepts valid ctx.workspaceDir directly', () => {
+    const resolved = resolveRequiredWorkspaceDir(api as any, { workspaceDir: '/active/workspace', agentId: 'main' }, { source: 'test' });
+    expect(resolved).toBe('/active/workspace');
+    expect(api.runtime.agent.resolveAgentWorkspaceDir).not.toHaveBeenCalled();
+  });
+
+  it('rejects home directory and resolves from agent id when available', () => {
+    const resolved = resolveWorkspaceDir(api as any, { workspaceDir: homeDir, agentId: 'worker-1' }, { source: 'test' });
+    expect(resolved).toBe('/resolved/workspace');
+    expect(api.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalledWith(api.config, 'worker-1');
+  });
+
+  it('throws in required mode when no valid workspace can be resolved', () => {
+    api.runtime.agent.resolveAgentWorkspaceDir.mockImplementation(() => {
+      throw new Error('no agent workspace');
+    });
+
+    expect(() => resolveRequiredWorkspaceDir(api as any, { workspaceDir: homeDir }, { source: 'command' })).toThrow(
+      /unable to resolve a valid workspace directory/i,
+    );
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  it('returns undefined in optional mode when no valid workspace can be resolved', () => {
+    api.runtime.agent.resolveAgentWorkspaceDir.mockImplementation(() => {
+      throw new Error('no agent workspace');
+    });
+
+    const resolved = resolveWorkspaceDir(api as any, { workspaceDir: homeDir }, { source: 'hook' });
+    expect(resolved).toBeUndefined();
+    expect(logger.warn).toHaveBeenCalled();
+  });
+
+  it('uses explicit fallbackAgentId when caller provides one', () => {
+    const resolved = resolveRequiredWorkspaceDir(api as any, {}, { source: 'startup', fallbackAgentId: 'main' });
+    expect(resolved).toBe('/resolved/workspace');
+    expect(api.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalledWith(api.config, 'main');
+  });
+});

package/tests/core/workspace-dir-validation.test.ts

@@ -1,68 +1,26 @@
-/**
- * Unit tests for workspace-dir-validation.ts
- * 
- * Tests the core validation logic and 3-tier fallback strategy
- * for resolving correct workspaceDir in tool hooks.
- */
-
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
 import * as os from 'os';
 import { validateWorkspaceDir, resolveValidWorkspaceDir, logWorkspaceDirHealth } from '../../src/core/workspace-dir-validation.js';
 
 const homeDir = os.homedir();
 
 describe('validateWorkspaceDir', () => {
-  it('should return error for undefined', () => {
-    const result = validateWorkspaceDir(undefined);
-    expect(result).toBe('workspaceDir is undefined/null');
-  });
-
-  it('should return error for null (treated as undefined)', () => {
-    const result = validateWorkspaceDir(null as unknown as string);
-    expect(result).toBe('workspaceDir is undefined/null');
-  });
-
-  it('should return error for empty string (treated as falsy)', () => {
-    const result = validateWorkspaceDir('');
-    // Empty string is falsy, so it's treated like undefined
-    expect(result).toContain('undefined/null');
-  });
-
-  it('should return error for root directory', () => {
-    const result = validateWorkspaceDir('/');
-    expect(result).toContain('root or empty');
-  });
-
-  it('should return error for home directory', () => {
-    const result = validateWorkspaceDir(homeDir);
-    expect(result).toContain('equals home directory');
-    expect(result).toContain(homeDir);
-  });
-
-  it('should return error for home directory with trailing slash', () => {
-    const result = validateWorkspaceDir(`${homeDir}/`);
-    expect(result).toContain('home directory');
+  it('rejects undefined or null values', () => {
+    expect(validateWorkspaceDir(undefined)).toBe('workspaceDir is undefined/null');
+    expect(validateWorkspaceDir(null as unknown as string)).toBe('workspaceDir is undefined/null');
   });
 
-  it('should return null (valid) for a proper workspace path', () => {
-    const result = validateWorkspaceDir('/home/user/projects/my-workspace');
-    expect(result).toBeNull();
+  it('rejects home directory and root-like paths', () => {
+    expect(validateWorkspaceDir(homeDir)).toContain('home directory');
+    expect(validateWorkspaceDir(`${homeDir}/`)).toContain('home directory');
+    expect(validateWorkspaceDir('/')).toContain('root or empty');
+    expect(validateWorkspaceDir('')).toContain('undefined/null');
   });
 
-  it('should return null (valid) for a nested workspace path', () => {
-    const result = validateWorkspaceDir('/home/user/.openclaw/workspace-main');
-    expect(result).toBeNull();
-  });
-
-  it('should return null (valid) for temp directory', () => {
-    const result = validateWorkspaceDir('/tmp/test-workspace');
-    expect(result).toBeNull();
-  });
-
-  it('should return null (valid) for Windows-style path', () => {
-    // On Linux, Windows paths are just regular paths
-    const result = validateWorkspaceDir('C:\\Users\\test\\workspace');
-    expect(result).toBeNull();
+  it('accepts normal workspace paths', () => {
+    expect(validateWorkspaceDir('/home/user/projects/workspace-main')).toBeNull();
+    expect(validateWorkspaceDir('/tmp/test-workspace')).toBeNull();
+    expect(validateWorkspaceDir('C:\\Users\\test\\workspace')).toBeNull();
   });
 });
 
@@ -81,108 +39,65 @@ describe('resolveValidWorkspaceDir', () => {
       },
     },
     config: {},
-    resolvePath: vi.fn(),
     logger: mockLogger,
   };
 
   beforeEach(() => {
     vi.clearAllMocks();
-    mockApi.resolvePath.mockReturnValue('/default/workspace');
     mockApi.runtime.agent.resolveAgentWorkspaceDir.mockReturnValue('/resolved/from/agent');
   });
 
-  afterEach(() => {
-    vi.resetAllMocks();
-  });
+  it('returns ctx.workspaceDir when valid', () => {
+    const result = resolveValidWorkspaceDir(
+      { workspaceDir: '/valid/workspace', agentId: 'main' },
+      mockApi as any,
+      { source: 'test' },
+    );
 
-  it('should return ctx.workspaceDir when valid', () => {
-    const ctx = { workspaceDir: '/valid/workspace', agentId: 'agent-1' };
-    const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'test' });
-    
     expect(result).toBe('/valid/workspace');
-    expect(mockLogger.warn).not.toHaveBeenCalled();
+    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).not.toHaveBeenCalled();
   });
 
-  it('should warn and continue when ctx.workspaceDir is home directory', () => {
-    const ctx = { workspaceDir: homeDir, agentId: 'agent-1' };
-    const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'test' });
-    
-    // Should fall back to agentId resolution
-    expect(result).toBe('/resolved/from/agent');
-    expect(mockLogger.warn).toHaveBeenCalled();
-  });
+  it('falls back to agent resolution when ctx.workspaceDir is invalid', () => {
+    const result = resolveValidWorkspaceDir(
+      { workspaceDir: homeDir, agentId: 'main' },
+      mockApi as any,
+      { source: 'test' },
+    );
 
-  it('should try agentId resolution when ctx.workspaceDir is undefined', () => {
-    const ctx = { workspaceDir: undefined, agentId: 'agent-1' };
-    const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'test' });
-    
-    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalledWith(mockApi.config, 'agent-1');
     expect(result).toBe('/resolved/from/agent');
+    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalledWith(mockApi.config, 'main');
   });
 
-  it('should fallback to resolvePath when agentId is undefined', () => {
-    const ctx = { workspaceDir: undefined, agentId: undefined };
-    const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'test' });
-    
-    expect(mockApi.resolvePath).toHaveBeenCalledWith('.');
-    expect(result).toBe('/default/workspace');
-  });
+  it('returns undefined when no valid workspace can be resolved', () => {
+    mockApi.runtime.agent.resolveAgentWorkspaceDir.mockReturnValue(homeDir);
 
-  it('should fallback to resolvePath when agentId resolution fails', () => {
-    mockApi.runtime.agent.resolveAgentWorkspaceDir.mockImplementation(() => {
-      throw new Error('Agent not found');
-    });
-    
-    const ctx = { workspaceDir: undefined, agentId: 'unknown-agent' };
-    const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'test' });
-    
-    expect(mockApi.resolvePath).toHaveBeenCalledWith('.');
-    expect(result).toBe('/default/workspace');
-    expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('failed to resolve from agentId'));
-  });
+    const result = resolveValidWorkspaceDir(
+      { workspaceDir: undefined, agentId: 'main' },
+      mockApi as any,
+      { source: 'test' },
+    );
 
-  it('should fallback to resolvePath when agentId resolution returns home directory', () => {
-    mockApi.runtime.agent.resolveAgentWorkspaceDir.mockReturnValue(homeDir);
-    
-    const ctx = { workspaceDir: undefined, agentId: 'agent-1' };
-    const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'test' });
-    
-    expect(mockApi.resolvePath).toHaveBeenCalledWith('.');
-    expect(result).toBe('/default/workspace');
-    expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('invalid'));
+    expect(result).toBeUndefined();
+    expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('unable to resolve a valid workspace directory'));
   });
 
-  it('should warn when all fallbacks fail', () => {
-    mockApi.resolvePath.mockReturnValue(homeDir);
-    
-    const ctx = { workspaceDir: undefined, agentId: undefined };
-    const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'test' });
-    
-    expect(result).toBe(homeDir);
-    expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('FINAL FALLBACK'));
-  });
+  it('supports explicit fallbackAgentId', () => {
+    mockApi.runtime.agent.resolveAgentWorkspaceDir
+      .mockImplementationOnce(() => {
+        throw new Error('agent missing');
+      })
+      .mockReturnValueOnce('/resolved/from/fallback');
 
-  it('should use custom onWarning callback', () => {
-    const customWarning = vi.fn();
-    
-    const ctx = { workspaceDir: homeDir, agentId: undefined };
-    mockApi.resolvePath.mockReturnValue('/valid/fallback');
-    
-    const result = resolveValidWorkspaceDir(ctx, mockApi as any, { 
-      source: 'test',
-      onWarning: customWarning,
-    });
-    
-    expect(customWarning).toHaveBeenCalled();
-  });
+    const result = resolveValidWorkspaceDir(
+      { workspaceDir: undefined, agentId: 'worker-1' },
+      mockApi as any,
+      { source: 'test', fallbackAgentId: 'main' },
+    );
 
-  it('should use default source "unknown" when not provided', () => {
-    const ctx = { workspaceDir: homeDir, agentId: undefined };
-    mockApi.resolvePath.mockReturnValue('/valid/fallback');
-    
-    resolveValidWorkspaceDir(ctx, mockApi as any);
-    
-    expect(mockLogger.warn).toHaveBeenCalledWith(expect.stringContaining('unknown:'));
+    expect(result).toBe('/resolved/from/fallback');
+    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenNthCalledWith(1, mockApi.config, 'worker-1');
+    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenNthCalledWith(2, mockApi.config, 'main');
   });
 });
 
@@ -201,7 +116,6 @@ describe('logWorkspaceDirHealth', () => {
       },
     },
     config: {},
-    resolvePath: vi.fn().mockReturnValue('/valid/workspace'),
     logger: mockLogger,
   };
 
@@ -209,64 +123,14 @@ describe('logWorkspaceDirHealth', () => {
     vi.clearAllMocks();
   });
 
-  it('should log info when workspaceDir is valid', () => {
-    const ctx = { workspaceDir: '/valid/workspace' };
-    logWorkspaceDirHealth(ctx, 'startup', mockApi as any);
-    
-    expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('✓'));
+  it('logs info when workspace is valid', () => {
+    logWorkspaceDirHealth({ workspaceDir: '/valid/workspace' }, 'startup', mockApi as any);
+    expect(mockLogger.info).toHaveBeenCalledWith(expect.stringContaining('workspaceDir="/valid/workspace" OK'));
   });
 
-  it('should log error when workspaceDir is invalid', () => {
-    mockApi.resolvePath.mockReturnValue(homeDir);
-    
-    const ctx = { workspaceDir: undefined };
-    logWorkspaceDirHealth(ctx, 'startup', mockApi as any);
-    
-    expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining(homeDir));
-  });
-});
-
-describe('Integration: 3-tier fallback chain', () => {
-  const mockLogger = {
-    warn: vi.fn(),
-    error: vi.fn(),
-    info: vi.fn(),
-    debug: vi.fn(),
-  };
-
-  it('should follow the complete fallback chain: ctx.workspaceDir -> agentId -> resolvePath', () => {
-    const mockApi = {
-      runtime: {
-        agent: {
-          resolveAgentWorkspaceDir: vi.fn().mockReturnValue('/workspace/from-agent'),
-        },
-      },
-      config: {},
-      resolvePath: vi.fn().mockReturnValue('/workspace/from-resolvePath'),
-      logger: mockLogger,
-    };
-
-    // Case 1: ctx.workspaceDir is valid - use it directly
-    const ctx1 = { workspaceDir: '/workspace/from-ctx', agentId: 'agent-1' };
-    const result1 = resolveValidWorkspaceDir(ctx1, mockApi as any, { source: 'test' });
-    expect(result1).toBe('/workspace/from-ctx');
-    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).not.toHaveBeenCalled();
-
-    vi.clearAllMocks();
-
-    // Case 2: ctx.workspaceDir is invalid, agentId resolution works
-    const ctx2 = { workspaceDir: homeDir, agentId: 'agent-1' };
-    const result2 = resolveValidWorkspaceDir(ctx2, mockApi as any, { source: 'test' });
-    expect(result2).toBe('/workspace/from-agent');
-    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalled();
-
-    vi.clearAllMocks();
-
-    // Case 3: ctx.workspaceDir is invalid, agentId resolution returns invalid, use resolvePath
+  it('logs error when workspace remains unresolved', () => {
     mockApi.runtime.agent.resolveAgentWorkspaceDir.mockReturnValue(homeDir);
-    const ctx3 = { workspaceDir: homeDir, agentId: 'agent-1' };
-    const result3 = resolveValidWorkspaceDir(ctx3, mockApi as any, { source: 'test' });
-    expect(result3).toBe('/workspace/from-resolvePath');
-    expect(mockApi.resolvePath).toHaveBeenCalledWith('.');
+    logWorkspaceDirHealth({ workspaceDir: undefined }, 'startup', mockApi as any);
+    expect(mockLogger.error).toHaveBeenCalledWith(expect.stringContaining('workspaceDir="undefined"'));
   });
 });

package/tests/hooks/pain.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { handleAfterToolCall } from '../../src/hooks/pain.js';
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 import * as ioUtils from '../../src/utils/io.js';
 import { WorkspaceContext } from '../../src/core/workspace-context.js';
 import { EventLogService } from '../../src/core/event-log.js';
@@ -82,6 +83,25 @@ describe('Post-Write Checks & Pain Hook', () => {
     expect(mockEmitSync).not.toHaveBeenCalled();
   });
 
+  it('skips processing when no valid workspace can be resolved', () => {
+    const mockCtx = { workspaceDir: undefined, agentId: 'main', sessionId: 's-invalid' };
+    const mockEvent = { toolName: 'write', params: {}, result: { exitCode: 0 }, error: undefined };
+    const mockApi = {
+      runtime: {
+        agent: {
+          resolveAgentWorkspaceDir: vi.fn().mockReturnValue(os.homedir()),
+        },
+      },
+      config: {},
+      logger: { warn: vi.fn(), error: vi.fn(), info: vi.fn(), debug: vi.fn() },
+    };
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any, mockApi as any);
+
+    expect(WorkspaceContext.fromHookContext).not.toHaveBeenCalled();
+    expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalledWith(mockApi.config, 'main');
+  });
+
   it('should capture pain on tool error with correct source', () => {
     const mockCtx = { workspaceDir, sessionId: 's1', api: { logger: {} } };
     const mockEvent = { 

package/tests/http/principles-console-route.test.ts

@@ -48,6 +48,17 @@ function createRequest(method: string, url: string, body?: string, headers?: Rec
 }
 
 describe('principles-console-route', () => {
+  const createApi = () => ({
+    rootDir: '/plugin',
+    logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    runtime: {
+      agent: {
+        resolveAgentWorkspaceDir: vi.fn(() => '/workspace'),
+      },
+    },
+    config: {},
+  });
+
   it('serves overview JSON from the plugin API route', async () => {
     vi.mocked(ControlUiQueryService).mockImplementation(function MockControlUiQueryService() {
       return {
@@ -56,11 +67,8 @@ describe('principles-console-route', () => {
       } as any;
     } as any);
 
-    const route = createPrinciplesConsoleRoute({
-      rootDir: '/plugin',
-      resolvePath: vi.fn(() => '/workspace'),
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    } as any);
+    const api = createApi();
+    const route = createPrinciplesConsoleRoute(api as any);
 
     const response = new MockResponse() as unknown as ServerResponse;
     const handled = await route.handler(
@@ -71,14 +79,11 @@ describe('principles-console-route', () => {
     expect(handled).toBe(true);
     expect((response as any).statusCode).toBe(200);
     expect((response as any).body).toContain('"workspaceDir": "/workspace"');
+    expect(api.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalled();
   });
 
   it('rejects unsupported asset methods with 405', async () => {
-    const route = createPrinciplesConsoleRoute({
-      rootDir: '/plugin',
-      resolvePath: vi.fn(() => '/workspace'),
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    } as any);
+    const route = createPrinciplesConsoleRoute(createApi() as any);
 
     const response = new MockResponse() as unknown as ServerResponse;
     const handled = await route.handler(
@@ -97,11 +102,7 @@ describe('principles-console-route', () => {
       } as any;
     } as any);
 
-    const route = createPrinciplesConsoleRoute({
-      rootDir: '/plugin',
-      resolvePath: vi.fn(() => '/workspace'),
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    } as any);
+    const route = createPrinciplesConsoleRoute(createApi() as any);
 
     const response = new MockResponse() as unknown as ServerResponse;
     const handled = await route.handler(
@@ -122,11 +123,7 @@ describe('principles-console-route', () => {
       } as any;
     } as any);
 
-    const route = createPrinciplesConsoleRoute({
-      rootDir: '/plugin',
-      resolvePath: vi.fn(() => '/workspace'),
-      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
-    } as any);
+    const route = createPrinciplesConsoleRoute(createApi() as any);
 
     const response = new MockResponse() as unknown as ServerResponse;
     const handled = await route.handler(
@@ -137,4 +134,29 @@ describe('principles-console-route', () => {
     expect(handled).toBe(true);
     expect((response as any).statusCode).toBe(404);
   });
+
+  it('fails fast when workspace resolution is unavailable', async () => {
+    vi.mocked(ControlUiQueryService).mockImplementation(function MockControlUiQueryService() {
+      return {
+        getOverview: () => ({ workspaceDir: '/workspace', generatedAt: 'now', dataFreshness: null }),
+        dispose: vi.fn(),
+      } as any;
+    } as any);
+
+    const api = createApi();
+    api.runtime.agent.resolveAgentWorkspaceDir = vi.fn(() => {
+      throw new Error('workspace unavailable');
+    });
+    const route = createPrinciplesConsoleRoute(api as any);
+
+    const response = new MockResponse() as unknown as ServerResponse;
+    const handled = await route.handler(
+      createRequest('GET', '/plugins/principles/api/overview'),
+      response,
+    );
+
+    expect(handled).toBe(true);
+    expect((response as any).statusCode).toBe(500);
+    expect((response as any).body).toContain('unable to resolve a valid workspace directory');
+  });
 });

package/tests/integration/empathy-workflow-integration.test.ts

@@ -20,8 +20,7 @@ import { handleBeforePromptBuild } from '../../src/hooks/prompt.js';
 import { WorkspaceContext } from '../../src/core/workspace-context.js';
 
 /**
- * Helper to create a mock function that properly reports as AsyncFunction.
- * This is required because isSubagentRuntimeAvailable() checks constructor.name === 'AsyncFunction'.
+ * Helper to create a mock async function for workflow-manager tests.
  */
 function mockAsyncFn<T extends (...args: any[]) => Promise<any>>(impl: (...args: any[]) => any) {
   const fn = vi.fn(impl) as unknown as T;

package/tests/integration/tool-hooks-workspace-dir.e2e.test.ts

@@ -79,7 +79,7 @@ describe('E2E: Tool Hooks workspaceDir Resolution', () => {
       expect(mockApi.runtime.agent.resolveAgentWorkspaceDir).toHaveBeenCalledWith(mockApi.config, 'test-agent');
     });
 
-    it('should fallback to resolvePath when agentId is also undefined', async () => {
+    it('should refuse to guess a workspace when agentId is also undefined', async () => {
       const { resolveValidWorkspaceDir } = await import('../../src/core/workspace-dir-validation.js');
       
       const mockApi = createMockApi(testWorkspaceDir);
@@ -90,8 +90,8 @@ describe('E2E: Tool Hooks workspaceDir Resolution', () => {
       
       const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'after_tool_call' });
       
-      expect(result).toBe(testWorkspaceDir);
-      expect(mockApi.resolvePath).toHaveBeenCalledWith('.');
+      expect(result).toBeUndefined();
+      expect(mockApi.resolvePath).not.toHaveBeenCalled();
     });
   });
 
@@ -129,26 +129,18 @@ describe('E2E: Tool Hooks workspaceDir Resolution', () => {
     });
   });
 
-  describe('Scenario 4: Warning is logged when workspaceDir resolution fails', () => {
-    it('should warn when falling back to resolvePath with invalid result', async () => {
+  describe('Scenario 4: Invalid workspace candidates are rejected', () => {
+    it('should return undefined when all workspace resolution candidates are invalid', async () => {
       const { resolveValidWorkspaceDir } = await import('../../src/core/workspace-dir-validation.js');
       
-      const mockApi = createMockApi(os.homedir()); // resolvePath returns home dir
-      mockApi.runtime.agent.resolveAgentWorkspaceDir.mockReturnValue(os.homedir()); // agentId also returns home
-      
-      const warningMessages: string[] = [];
-      const onWarning = (msg: string) => warningMessages.push(msg);
+      const mockApi = createMockApi(os.homedir());
+      mockApi.runtime.agent.resolveAgentWorkspaceDir.mockReturnValue(os.homedir());
       
       const ctx = { workspaceDir: undefined, agentId: 'test-agent' };
       
-      const result = resolveValidWorkspaceDir(ctx, mockApi as any, { 
-        source: 'test',
-        onWarning,
-      });
+      const result = resolveValidWorkspaceDir(ctx, mockApi as any, { source: 'test' });
       
-      // Should have warnings about invalid paths
-      expect(warningMessages.length).toBeGreaterThan(0);
-      expect(warningMessages.some(m => m.includes('FINAL FALLBACK') || m.includes('invalid'))).toBe(true);
+      expect(result).toBeUndefined();
     });
   });
 });

package/tests/service/empathy-observer-workflow-manager.test.ts

@@ -6,8 +6,7 @@ import { EmpathyObserverWorkflowManager } from '../../src/service/subagent-workf
 import type { SubagentWorkflowSpec } from '../../src/service/subagent-workflow/types.js';
 
 /**
- * Helper to create a mock function that properly reports as AsyncFunction.
- * This is required because isSubagentRuntimeAvailable() checks constructor.name === 'AsyncFunction'.
+ * Helper to create a mock async function for workflow-manager tests.
  */
 function mockAsyncFn<T extends (...args: any[]) => Promise<any>>(impl: (...args: any[]) => any) {
     const fn = vi.fn(impl) as unknown as T;