Skip to content

Garry's Opinionated OpenClaw/Hermes Agent Brain

TypeScript

Report a hook lane worker that dies before answering as an internal error

garrytan351a3af0eb40
diff --git a/src/core/setup/skill-resolver-config.ts b/src/core/setup/skill-resolver-config.ts
index fc47929ef2..25a83af3aa 100644
--- a/src/core/setup/skill-resolver-config.ts
+++ b/src/core/setup/skill-resolver-config.ts
@@ -127,7 +127,7 @@ export function runSkillResolverConfigKey(args: string[], home: string): boolean
const doc = read.state === 'ok' ? structuredClone(read.doc) : {};
const section = resolverSection(doc);
const perHarness = (section.per_harness && typeof section.per_harness === 'object' && !Array.isArray(section.per_harness) ? section.per_harness : {}) as Record<string, Record<string, unknown>>;
- const holder: Record<string, unknown> = nested ? (perHarness[nested[1]!] ??= {}) : section;
+ const holder: Record<string, unknown> = nested ? (Object.hasOwn(perHarness, nested[1]!) ? perHarness[nested[1]!]! : (perHarness[nested[1]!] = {})) : section;
const field = nested ? nested[2]! : leaf;
if (action === 'get') {
if (holder[field] === undefined) return fail(`Config key not found: ${key}`);
diff --git a/src/core/skills/resolver/hook-lane.ts b/src/core/skills/resolver/hook-lane.ts
index b39cd8f9f4..1181aead65 100644
--- a/src/core/skills/resolver/hook-lane.ts
+++ b/src/core/skills/resolver/hook-lane.ts
@@ -65,7 +65,7 @@ import { assertCatalogName, catalogFile, logsDir, resolverHome } from './paths.t
import { type CommitHold, commitSessionAsync, sessionKey, type TurnDelta } from './session.ts';
import type { TurnOutput } from './resolve.ts';
import type { LaneWorkerTurn } from './hook-worker.ts';
-import { startLaneWorker } from './lane-worker.ts';
+import { laneWorkerFailed, startLaneWorker } from './lane-worker.ts';
import { releaseLease } from './lock.ts';
export { WORKER_SRC_PATH } from './lane-worker.ts';
@@ -284,10 +284,11 @@ async function laneTurn(event: 'user-prompt' | 'session-start', harness: LaneHar
}
const worker = ctl.worker;
- if (!worker) return { outcome: 'error', code: 'skill_resolver_internal', catalogs };
+ if (!worker || laneWorkerFailed()) return { outcome: 'error', code: 'skill_resolver_internal', catalogs };
const posted = await new Promise<{ output?: TurnOutput; pending?: { key: string; delta: TurnDelta } | null; error?: { code: string } }>((resolve) => {
worker.once('message', resolve);
worker.once('error', () => resolve({ error: { code: 'skill_resolver_internal' } }));
+ worker.once('exit', () => resolve({ error: { code: 'skill_resolver_internal' } }));
worker.postMessage({ input: { message: prompt, harness, ...turnSettings, ...(sessionId ? { session_id: sessionId } : {}) }, home, catalogs, deadlineMs: Math.max(1, deadlineMs - elapsed() - COMMIT_RESERVE_MS) } satisfies LaneWorkerTurn);
});
if (posted.error || !posted.output) return { outcome: 'error', code: posted.error?.code ?? 'skill_resolver_internal', catalogs };
diff --git a/src/core/skills/resolver/hook-worker.ts b/src/core/skills/resolver/hook-worker.ts
index 6b9a7d6a00..791e7019ca 100644
--- a/src/core/skills/resolver/hook-worker.ts
+++ b/src/core/skills/resolver/hook-worker.ts
@@ -10,9 +10,10 @@
*
* GBRAIN_TEST_SKILL_LANE_STALL (tests only) forces a slow stage: block
* (synchronous 10 s busy loop), hang (never answers), late (answers after
- * 300 ms); commit-held and commit-written (hook-lane.ts) stop the main
- * thread's commit once it holds the lease, or once its temp file is
- * written. GBRAIN_TEST_SKILL_LANE_DEADLINE_MS (tests only, hook-lane.ts)
+ * 300 ms), load-error (throws while loading), exit (waits on nothing, so
+ * the thread ends without answering); commit-held and commit-written
+ * (hook-lane.ts) stop the main thread's commit once it holds the lease, or
+ * once its temp file is written. GBRAIN_TEST_SKILL_LANE_DEADLINE_MS (tests only, hook-lane.ts)
* widens the lane's deadline so a loaded test machine can assert delivery.
*/
import { parentPort, workerData } from 'node:worker_threads';
@@ -22,10 +23,12 @@ export interface LaneWorkerData { stall?: string }
export interface LaneWorkerTurn { input: unknown; home: string; catalogs: string[]; deadlineMs: number }
const { stall } = (workerData ?? {}) as LaneWorkerData;
+if (stall === 'load-error') throw new Error('forced worker load failure');
const { input, home, catalogs, deadlineMs } = await new Promise<LaneWorkerTurn>(resolve => parentPort!.once('message', resolve));
if (stall === 'block') { const end = Date.now() + 10_000; while (Date.now() < end) { /* forced synchronous stall */ } }
-if (stall === 'hang') await new Promise(() => {});
+if (stall === 'hang') await new Promise(() => setInterval(() => {}, 60_000));
+if (stall === 'exit') await new Promise(() => {});
if (stall === 'late') await new Promise(r => setTimeout(r, 300));
try {
diff --git a/src/core/skills/resolver/lane-worker.ts b/src/core/skills/resolver/lane-worker.ts
index 38a104deb8..37e4c80559 100644
--- a/src/core/skills/resolver/lane-worker.ts
+++ b/src/core/skills/resolver/lane-worker.ts
@@ -15,6 +15,7 @@ export const WORKER_SRC_PATH = 'core/skills/resolver/hook-worker.ts';
const workerEntry = (): string | URL => (/[\\/](\$bunfs|~BUN)[\\/]/.test(import.meta.url) ? Bun.main.replace(/[^\\/]*$/, '') + WORKER_SRC_PATH : new URL('./hook-worker.ts', import.meta.url));
let started: Worker | null = null;
+let failed = false;
/** Start the worker (once per process). Null when it cannot start; the lane then reports skill_resolver_internal. */
export function startLaneWorker(env: NodeJS.ProcessEnv = process.env): Worker | null {
@@ -22,7 +23,11 @@ export function startLaneWorker(env: NodeJS.ProcessEnv = process.env): Worker |
try {
started = new Worker(workerEntry(), { workerData: { stall: env.GBRAIN_TEST_SKILL_LANE_STALL } });
started.unref();
- started.on('error', () => {});
+ started.on('error', () => { failed = true; });
+ started.on('exit', () => { failed = true; });
} catch { started = null; }
return started;
}
+
+/** True once the started worker has failed or exited, which can happen before the lane is ready to listen. */
+export const laneWorkerFailed = (): boolean => failed;
diff --git a/test/skill-resolver-hook-lane.test.ts b/test/skill-resolver-hook-lane.test.ts
index 60e3aa6cf2..d44b9a492f 100644
--- a/test/skill-resolver-hook-lane.test.ts
+++ b/test/skill-resolver-hook-lane.test.ts
@@ -83,10 +83,10 @@ async function hook(b: Box, command: string, payload: Record<string, unknown>, e
return { stdout, stderr, exitCode, wallMs: performance.now() - t0 };
}
const WIDE = { GBRAIN_TEST_SKILL_LANE_DEADLINE_MS: '10000' };
-const laneLog = (b: Box): any[] => {
- const p = join(b.home, '.gbrain', 'skill-index', 'logs', dailyLogFile(LANE_LOG, Date.now()));
+const laneLog = (b: Box): any[] => [Date.now() - 86_400_000, Date.now()].flatMap((ms) => {
+ const p = join(b.home, '.gbrain', 'skill-index', 'logs', dailyLogFile(LANE_LOG, ms));
return existsSync(p) ? readFileSync(p, 'utf8').trim().split('\n').filter(Boolean).map((l) => JSON.parse(l)) : [];
-};
+});
const sessions = (b: Box) => { const d = join(b.home, '.gbrain', 'skill-index', 'sessions'); return existsSync(d) ? readdirSync(d) : []; };
const contextOf = (r: Run) => JSON.parse(r.stdout).hookSpecificOutput.additionalContext as string;
@@ -186,6 +186,19 @@ describe('skill-resolver lane: deadline, measured outside the process', () => {
expect(sessions(b).some((s) => readFileSync(join(b.home, '.gbrain', 'skill-index', 'sessions', s), 'utf8').includes('deploy-widget'))).toBe(false);
});
}
+
+ for (const stall of ['load-error', 'exit'] as const) {
+ test(`${stall}: a worker that fails before answering is logged as skill_resolver_internal, not as a timeout`, async () => {
+ const b = box();
+ seedSkills(claudeSkills(b));
+ await setup(b, 'claude-code');
+ const cmd = wired(b, 'claude-code');
+ const r = await hook(b, cmd, { prompt: 'please deploy the widget to staging', session_id: 'sess-l' }, { ...WIDE, GBRAIN_TEST_SKILL_LANE_STALL: stall });
+ expect(r.exitCode).toBe(0);
+ expect(r.stdout).toBe('');
+ expect(laneLog(b).at(-1)).toMatchObject({ outcome: 'error', code: 'skill_resolver_internal' });
+ });
+ }
});
describe('skill-resolver lane: turn settings from config', () => {
@@ -221,6 +234,9 @@ describe('skill-resolver lane: turn settings from config', () => {
const bad = await config(b, 'set', 'skills.resolver.per_harness.vim.top_k', '2');
expect(bad.exitCode).not.toBe(0);
expect(bad.stderr).toContain('names no harness');
+ const inherited = await config(b, 'set', 'skills.resolver.per_harness.constructor.top_k', '2');
+ expect(inherited.exitCode).not.toBe(0);
+ expect(inherited.stderr).toContain('names no harness');
expect((await config(b, 'set', 'skills.resolver.top_k', '9')).exitCode).not.toBe(0);
const cfg = JSON.parse(readFileSync(join(b.home, '.gbrain', 'config.json'), 'utf8')).skills.resolver;
expect([cfg.top_k, cfg.min_match, cfg.pinned, cfg.per_harness]).toEqual([1, 'named', ['deploy-widget'], { codex: { top_k: 2 } }]);