@qvac/harness 0.8.8 → 0.8.10

package/dist-lib/lib/errors.d.ts

@@ -0,0 +1,266 @@
+import { QvacErrorBase } from '@qvac/error';
+export declare const CONTEXT_OVERFLOW_MESSAGE = "This message is too large for the model context window.";
+export declare const IMAGE_LOAD_STALL_ERROR = "image model download stalled";
+export declare const TRANSLATION_LOAD_STALL_ERROR = "translation model download stalled";
+export declare const NO_STORAGE_ROOT = "cannot fence the app storage root: the SDK home is unknown";
+declare const HARNESS_ERRORS: {
+    readonly ABORTED: {
+        readonly code: 102001;
+        readonly message: () => string;
+    };
+    readonly HARNESS_CLOSING: {
+        readonly code: 102002;
+        readonly message: () => string;
+    };
+    readonly HARNESS_SUSPENDED: {
+        readonly code: 102003;
+        readonly message: () => string;
+    };
+    readonly HARNESS_EXITED_BEFORE_READY: {
+        readonly code: 102004;
+        readonly message: (exitCode: number | null) => string;
+    };
+    readonly CAPABILITY_UNSUPPORTED: {
+        readonly code: 102005;
+        readonly message: (what: string) => string;
+    };
+    readonly UNKNOWN_CAPABILITY: {
+        readonly code: 102006;
+        readonly message: (capability: string) => string;
+    };
+    readonly CLIENT_GONE: {
+        readonly code: 102007;
+        readonly message: () => string;
+    };
+    readonly RPC_STREAM_DESTROYED: {
+        readonly code: 102008;
+        readonly message: () => string;
+    };
+    readonly EMBED_ABORTED: {
+        readonly code: 102009;
+        readonly message: () => string;
+    };
+    readonly NO_SKILLS_OVERLAY: {
+        readonly code: 102010;
+        readonly message: () => string;
+    };
+    readonly CHAT_MODEL_BUSY: {
+        readonly code: 102101;
+        readonly message: (output: string) => string;
+    };
+    readonly MODEL_NOT_RESIDENT: {
+        readonly code: 102102;
+        readonly message: (model: string) => string;
+    };
+    readonly AUDIOGEN_MODEL_NOT_FOUND: {
+        readonly code: 102103;
+        readonly message: (model: string) => string;
+    };
+    readonly MODEL_NOT_IN_REGISTRY: {
+        readonly code: 102104;
+        readonly message: (model: string, addon: string) => string;
+    };
+    readonly MODEL_LOAD_CLOCK_SKEW: {
+        readonly code: 102105;
+        readonly message: (model: string) => string;
+    };
+    readonly IMAGE_LOAD_STALLED: {
+        readonly code: 102106;
+        readonly message: () => string;
+    };
+    readonly TRANSLATION_LOAD_STALLED: {
+        readonly code: 102107;
+        readonly message: () => string;
+    };
+    readonly CONTEXT_WINDOW_EXCEEDED: {
+        readonly code: 102201;
+        readonly message: () => string;
+    };
+    readonly TTS_NO_AUDIO: {
+        readonly code: 102202;
+        readonly message: () => string;
+    };
+    readonly TTS_INCOMPLETE: {
+        readonly code: 102203;
+        readonly message: () => string;
+    };
+    readonly FETCH_TIMED_OUT: {
+        readonly code: 102301;
+        readonly message: (ms: number) => string;
+    };
+    readonly FETCH_CANCELLED: {
+        readonly code: 102302;
+        readonly message: () => string;
+    };
+    readonly RESPONSE_NOT_JSON: {
+        readonly code: 102303;
+        readonly message: (chars: number, detail: string) => string;
+    };
+    readonly HTTP_STATUS: {
+        readonly code: 102304;
+        readonly message: (status: number) => string;
+    };
+    readonly SEARCH_CAPTCHA: {
+        readonly code: 102305;
+        readonly message: (engine: string) => string;
+    };
+    readonly RESPONSE_TOO_LARGE: {
+        readonly code: 102306;
+        readonly message: (maxBytes: number) => string;
+    };
+    readonly UNSUPPORTED_HTTP_METHOD: {
+        readonly code: 102307;
+        readonly message: (method: string) => string;
+    };
+    readonly GEOCODER_HTTP_STATUS: {
+        readonly code: 102308;
+        readonly message: (status: number) => string;
+    };
+    readonly EGRESS_BLOCKED: {
+        readonly code: 102309;
+        readonly message: (reason: string) => string;
+    };
+    readonly OFFICE_UNSUPPORTED_DOCUMENT: {
+        readonly code: 102401;
+        readonly message: (fileName: string) => string;
+    };
+    readonly OFFICE_TOO_LARGE: {
+        readonly code: 102402;
+        readonly message: (bytes: number, limit: number) => string;
+    };
+    readonly OFFICE_EXTRACTION_ABORTED: {
+        readonly code: 102403;
+        readonly message: (fileName: string) => string;
+    };
+    readonly OFFICE_EXTRACTION_FAILED: {
+        readonly code: 102404;
+        readonly message: (fileName: string, detail: string) => string;
+    };
+    readonly OFFICE_OP_UNAVAILABLE: {
+        readonly code: 102405;
+        readonly message: (op: string) => string;
+    };
+    readonly COMMAND_TIMED_OUT: {
+        readonly code: 102501;
+        readonly message: (ms: number) => string;
+    };
+    readonly PACKAGE_INSTALL_TIMED_OUT: {
+        readonly code: 102502;
+        readonly message: (ms: number) => string;
+    };
+    readonly PYTHON_WORKER_FAILED: {
+        readonly code: 102503;
+        readonly message: (detail: string) => string;
+    };
+    readonly PYTHON_WORKER_EXITED: {
+        readonly code: 102504;
+        readonly message: (exitCode: number) => string;
+    };
+    readonly ATTACHMENT_STAGING_TIMED_OUT: {
+        readonly code: 102505;
+        readonly message: (ms: number) => string;
+    };
+    readonly FETCH_REFUSED: {
+        readonly code: 102506;
+        readonly message: (reason: string) => string;
+    };
+    readonly OBSIDIAN_NOTE_NAME_IS_PATH: {
+        readonly code: 102601;
+        readonly message: () => string;
+    };
+    readonly OBSIDIAN_NOTE_NOT_FOUND: {
+        readonly code: 102602;
+        readonly message: (args: readonly string[]) => string;
+    };
+    readonly OBSIDIAN_MISSING_ARGUMENT: {
+        readonly code: 102603;
+        readonly message: (names: string) => string;
+    };
+    readonly OBSIDIAN_NO_PROPERTIES: {
+        readonly code: 102604;
+        readonly message: () => string;
+    };
+    readonly OBSIDIAN_NOTE_EXISTS: {
+        readonly code: 102605;
+        readonly message: (name: string, folder: string) => string;
+    };
+    readonly OBSIDIAN_ACTION_UNSUPPORTED: {
+        readonly code: 102606;
+        readonly message: (action: string) => string;
+    };
+    readonly OBSIDIAN_NOTE_CHANGED: {
+        readonly code: 102607;
+        readonly message: (why: string, file: string) => string;
+    };
+    readonly OBSIDIAN_PATH_CROSSES_SYMLINK: {
+        readonly code: 102608;
+        readonly message: (target: string) => string;
+    };
+    readonly OBSIDIAN_PATH_ESCAPES_VAULT: {
+        readonly code: 102609;
+        readonly message: (rel: string) => string;
+    };
+    readonly OBSIDIAN_DESTINATION_EXISTS: {
+        readonly code: 102610;
+        readonly message: (filePath: string) => string;
+    };
+    readonly SKILL_FILE_NOT_FOUND: {
+        readonly code: 102701;
+        readonly message: (name: string, file: string) => string;
+    };
+    readonly INVALID_SKILL_NAME: {
+        readonly code: 102702;
+        readonly message: (name: string) => string;
+    };
+    readonly SKILL_NOT_FOUND: {
+        readonly code: 102703;
+        readonly message: (name: string) => string;
+    };
+    readonly BUNDLED_SKILLS_INVALID: {
+        readonly code: 102704;
+        readonly message: (staging: string) => string;
+    };
+    readonly BUNDLED_SKILLS_TAMPERED: {
+        readonly code: 102705;
+        readonly message: (dir: string) => string;
+    };
+    readonly BUNDLED_SKILLS_OCCUPIED: {
+        readonly code: 102706;
+        readonly message: (dir: string, why: string) => string;
+    };
+    readonly DRIVE_TIMED_OUT: {
+        readonly code: 102707;
+        readonly message: (op: string) => string;
+    };
+    readonly DRIVE_READ_TRUNCATED: {
+        readonly code: 102708;
+        readonly message: (maxBytes: number, key: string) => string;
+    };
+    readonly NO_STORAGE_ROOT: {
+        readonly code: 102709;
+        readonly message: () => string;
+    };
+    readonly SLM_TRANSLATION_UNAVAILABLE: {
+        readonly code: 102710;
+        readonly message: () => string;
+    };
+    readonly PDF_TEXT_UNAVAILABLE: {
+        readonly code: 102711;
+        readonly message: () => string;
+    };
+};
+type Errors = typeof HARNESS_ERRORS;
+export type HarnessErrorName = keyof Errors;
+type Adds<K extends HarnessErrorName> = Parameters<Errors[K]['message']>;
+interface HarnessErrorOptions {
+    readonly cause?: unknown;
+}
+type HarnessErrorArgs<K extends HarnessErrorName> = [
+] extends Adds<K> ? [adds?: Adds<K>, opts?: HarnessErrorOptions] : [adds: Adds<K>, opts?: HarnessErrorOptions];
+export declare class HarnessError<K extends HarnessErrorName = HarnessErrorName> extends QvacErrorBase {
+    constructor(name: K, ...[adds, opts]: HarnessErrorArgs<K>);
+}
+export declare function harnessErrorCode(name: HarnessErrorName): number;
+export declare function harnessErrorCodes(): ReadonlyArray<number>;
+export declare function isHarnessError(err: unknown, name: HarnessErrorName): boolean;
+export {};

package/dist-lib/lib/errors.js

@@ -0,0 +1,189 @@
+import { QvacErrorBase, addCodes } from '@qvac/error';
+import { isRecord } from './guards.js';
+export const CONTEXT_OVERFLOW_MESSAGE = 'This message is too large for the model context window.';
+export const IMAGE_LOAD_STALL_ERROR = 'image model download stalled';
+export const TRANSLATION_LOAD_STALL_ERROR = 'translation model download stalled';
+export const NO_STORAGE_ROOT = 'cannot fence the app storage root: the SDK home is unknown';
+const HARNESS_ERRORS = {
+    ABORTED: { code: 102001, message: () => 'aborted' },
+    HARNESS_CLOSING: { code: 102002, message: () => 'harness is closing' },
+    HARNESS_SUSPENDED: { code: 102003, message: () => 'harness is suspended' },
+    HARNESS_EXITED_BEFORE_READY: {
+        code: 102004,
+        message: (exitCode) => `harness exited (${exitCode}) before ready`
+    },
+    CAPABILITY_UNSUPPORTED: {
+        code: 102005,
+        message: (what) => `harness does not support ${what}`
+    },
+    UNKNOWN_CAPABILITY: {
+        code: 102006,
+        message: (capability) => `unknown capability: ${capability}`
+    },
+    CLIENT_GONE: { code: 102007, message: () => 'client gone' },
+    RPC_STREAM_DESTROYED: { code: 102008, message: () => 'rpc stream destroyed' },
+    EMBED_ABORTED: { code: 102009, message: () => 'embed aborted' },
+    NO_SKILLS_OVERLAY: { code: 102010, message: () => 'no writable skills overlay is configured' },
+    CHAT_MODEL_BUSY: {
+        code: 102101,
+        message: (output) => `the chat model is busy; try the ${output} again once the current reply finishes`
+    },
+    MODEL_NOT_RESIDENT: {
+        code: 102102,
+        message: (model) => `${model} loads for each generation and is not kept in memory`
+    },
+    AUDIOGEN_MODEL_NOT_FOUND: {
+        code: 102103,
+        message: (model) => `audiogen model not found: ${model}`
+    },
+    MODEL_NOT_IN_REGISTRY: {
+        code: 102104,
+        message: (model, addon) => `model not found in registry: ${model} (addon=${addon})`
+    },
+    MODEL_LOAD_CLOCK_SKEW: {
+        code: 102105,
+        message: (model) => `model load abandoned: system clock moved backward mid-load: ${model}`
+    },
+    IMAGE_LOAD_STALLED: { code: 102106, message: () => IMAGE_LOAD_STALL_ERROR },
+    TRANSLATION_LOAD_STALLED: { code: 102107, message: () => TRANSLATION_LOAD_STALL_ERROR },
+    CONTEXT_WINDOW_EXCEEDED: { code: 102201, message: () => CONTEXT_OVERFLOW_MESSAGE },
+    TTS_NO_AUDIO: { code: 102202, message: () => 'Text-to-speech returned no audio.' },
+    TTS_INCOMPLETE: { code: 102203, message: () => 'tts synthesis did not complete' },
+    FETCH_TIMED_OUT: { code: 102301, message: (ms) => `Request timed out after ${ms}ms` },
+    FETCH_CANCELLED: { code: 102302, message: () => 'Request cancelled' },
+    RESPONSE_NOT_JSON: {
+        code: 102303,
+        message: (chars, detail) => `Response was not valid JSON (${chars} chars): ${detail}`
+    },
+    HTTP_STATUS: { code: 102304, message: (status) => `HTTP ${status}` },
+    SEARCH_CAPTCHA: { code: 102305, message: (engine) => `${engine} CAPTCHA detected` },
+    RESPONSE_TOO_LARGE: {
+        code: 102306,
+        message: (maxBytes) => `response exceeded ${maxBytes} bytes`
+    },
+    UNSUPPORTED_HTTP_METHOD: {
+        code: 102307,
+        message: (method) => `unsupported HTTP method: ${method}`
+    },
+    GEOCODER_HTTP_STATUS: {
+        code: 102308,
+        message: (status) => `geocoder answered HTTP ${status}`
+    },
+    EGRESS_BLOCKED: { code: 102309, message: (reason) => reason },
+    OFFICE_UNSUPPORTED_DOCUMENT: {
+        code: 102401,
+        message: (fileName) => `Unsupported Office document: ${fileName}`
+    },
+    OFFICE_TOO_LARGE: {
+        code: 102402,
+        message: (bytes, limit) => `document is too large to extract: ${bytes} bytes, limit ${limit}`
+    },
+    OFFICE_EXTRACTION_ABORTED: {
+        code: 102403,
+        message: (fileName) => `${fileName}: extraction aborted`
+    },
+    OFFICE_EXTRACTION_FAILED: {
+        code: 102404,
+        message: (fileName, detail) => `${fileName}: ${detail}`
+    },
+    OFFICE_OP_UNAVAILABLE: {
+        code: 102405,
+        message: (op) => `${op} is not available on this file`
+    },
+    COMMAND_TIMED_OUT: { code: 102501, message: (ms) => `Command timed out after ${ms}ms` },
+    PACKAGE_INSTALL_TIMED_OUT: {
+        code: 102502,
+        message: (ms) => `package install timed out after ${ms}ms`
+    },
+    PYTHON_WORKER_FAILED: { code: 102503, message: (detail) => `python worker: ${detail}` },
+    PYTHON_WORKER_EXITED: {
+        code: 102504,
+        message: (exitCode) => `python worker exited with code ${exitCode}`
+    },
+    ATTACHMENT_STAGING_TIMED_OUT: {
+        code: 102505,
+        message: (ms) => `staging attachments timed out after ${ms}ms`
+    },
+    FETCH_REFUSED: { code: 102506, message: (reason) => `fetch refused: ${reason}` },
+    OBSIDIAN_NOTE_NAME_IS_PATH: {
+        code: 102601,
+        message: () => 'name= must be a note name, not a path.'
+    },
+    OBSIDIAN_NOTE_NOT_FOUND: {
+        code: 102602,
+        message: (args) => `Note not found. Args: ${args.join(', ')}`
+    },
+    OBSIDIAN_MISSING_ARGUMENT: {
+        code: 102603,
+        message: (names) => `Missing required argument: ${names}`
+    },
+    OBSIDIAN_NO_PROPERTIES: { code: 102604, message: () => 'No property key=value pairs provided.' },
+    OBSIDIAN_NOTE_EXISTS: {
+        code: 102605,
+        message: (name, folder) => `Note "${name}" already exists at ${folder}`
+    },
+    OBSIDIAN_ACTION_UNSUPPORTED: {
+        code: 102606,
+        message: (action) => `Action "${action}" is not supported in vault file mode. ` +
+            `This action requires the Obsidian CLI connected to the running app.`
+    },
+    OBSIDIAN_NOTE_CHANGED: {
+        code: 102607,
+        message: (why, file) => `Note changed on disk during update (${why}): ${file}`
+    },
+    OBSIDIAN_PATH_CROSSES_SYMLINK: {
+        code: 102608,
+        message: (target) => `Path "${target}" crosses a symlink inside the vault.`
+    },
+    OBSIDIAN_PATH_ESCAPES_VAULT: {
+        code: 102609,
+        message: (rel) => `Path "${rel}" escapes the vault root.`
+    },
+    OBSIDIAN_DESTINATION_EXISTS: {
+        code: 102610,
+        message: (filePath) => `Destination already exists: ${filePath}`
+    },
+    SKILL_FILE_NOT_FOUND: {
+        code: 102701,
+        message: (name, file) => `ENOENT: ${name}/${file}`
+    },
+    INVALID_SKILL_NAME: { code: 102702, message: (name) => `invalid skill name: ${name}` },
+    SKILL_NOT_FOUND: { code: 102703, message: (name) => `skill not found: ${name}` },
+    BUNDLED_SKILLS_INVALID: {
+        code: 102704,
+        message: (staging) => `bundled skills staging dir ${staging} failed validation`
+    },
+    BUNDLED_SKILLS_TAMPERED: {
+        code: 102705,
+        message: (dir) => `bundled skills dir ${dir} failed validation after a rewrite — ` +
+            'another process is tampering with it; remove it and restart'
+    },
+    BUNDLED_SKILLS_OCCUPIED: {
+        code: 102706,
+        message: (dir, why) => `bundled skills dir ${dir} could not be read or replaced${why} — remove it and restart`
+    },
+    DRIVE_TIMED_OUT: { code: 102707, message: (op) => `drive ${op} timed out` },
+    DRIVE_READ_TRUNCATED: {
+        code: 102708,
+        message: (maxBytes, key) => `read stopped at ${maxBytes} bytes: ${key}`
+    },
+    NO_STORAGE_ROOT: { code: 102709, message: () => NO_STORAGE_ROOT },
+    SLM_TRANSLATION_UNAVAILABLE: { code: 102710, message: () => 'slm translation is unavailable' },
+    PDF_TEXT_UNAVAILABLE: { code: 102711, message: () => 'PDF text is not available on this device' }
+};
+addCodes(Object.fromEntries(Object.entries(HARNESS_ERRORS).map(([name, { code, message }]) => [code, { name, message }])), { name: '@qvac/harness', version: `${Object.keys(HARNESS_ERRORS).length}.0.0` });
+export class HarnessError extends QvacErrorBase {
+    constructor(name, ...[adds, opts]) {
+        const cause = opts?.cause instanceof Error ? opts.cause : undefined;
+        super({ code: HARNESS_ERRORS[name].code, adds: adds ?? [], cause });
+    }
+}
+export function harnessErrorCode(name) {
+    return HARNESS_ERRORS[name].code;
+}
+export function harnessErrorCodes() {
+    return Object.values(HARNESS_ERRORS).map(({ code }) => code);
+}
+export function isHarnessError(err, name) {
+    return isRecord(err) && String(err.code) === String(HARNESS_ERRORS[name].code);
+}

package/dist-lib/lib/helpers/load-stall.d.ts

@@ -3,4 +3,4 @@ export interface LoadStall {
     clear: () => void;
     promise: Promise<never>;
 }
-export declare function createLoadStall(ms: number, message: string): LoadStall;
+export declare function createLoadStall(ms: number, stalled: () => Error): LoadStall;

package/dist-lib/lib/helpers/load-stall.js

@@ -1,4 +1,4 @@
-export function createLoadStall(ms, message) {
+export function createLoadStall(ms, stalled) {
     let timer = null;
     let rejectStall = null;
     const promise = new Promise((_, reject) => {
@@ -9,7 +9,7 @@ export function createLoadStall(ms, message) {
             clearTimeout(timer);
         }
         timer = setTimeout(() => {
-            rejectStall?.(new Error(message));
+            rejectStall?.(stalled());
         }, ms);
     };
     arm();

package/dist-lib/lib/helpers/race-abort.d.ts

@@ -1,5 +1,6 @@
 import type { AbortSignal as BareAbortSignal } from 'bare-abort-controller';
-export declare class AbortedError extends Error {
+import { HarnessError } from '../errors.ts';
+export declare class AbortedError extends HarnessError<'ABORTED'> {
     constructor();
 }
 export declare function raceAbort<T>(promise: Promise<T>, signal?: BareAbortSignal): Promise<T>;

package/dist-lib/lib/helpers/race-abort.js

@@ -1,8 +1,7 @@
-export class AbortedError extends Error {
+import { HarnessError } from '../errors.js';
+export class AbortedError extends HarnessError {
     constructor() {
-        super('aborted');
-        this.name = 'AbortedError';
-        Error.captureStackTrace?.(this, AbortedError);
+        super('ABORTED');
     }
 }
 export function raceAbort(promise, signal) {

package/dist-lib/lib/hooks/built-in/arg-repair.js

@@ -1,6 +1,6 @@
 import { jsonrepair } from 'jsonrepair';
 import { isRecord } from '../../guards.js';
-import { hlog } from '../../log.js';
+import { log } from '../../log.js';
 import { escapeLiteralDollars } from '../../tools/exec/scope.js';
 const STRUCTURED_TYPES = new Set(['object', 'array']);
 export class ArgRepairHook {
@@ -20,7 +20,7 @@ export class ArgRepairHook {
             }
             const parsed = parseStructured(value, types);
             if (parsed === null) {
-                hlog('arg repair declined', { tool: ctx.toolName, param: key, length: value.length });
+                log.debug('arg repair declined', { tool: ctx.toolName, param: key, length: value.length });
                 continue;
             }
             args = { ...args, [key]: parsed };

package/dist-lib/lib/hooks/pipeline.js

@@ -1,4 +1,4 @@
-import { hlog } from '../log.js';
+import { log } from '../log.js';
 import { normalizeToolExecutionOutcome } from '../helpers/run-outcome.js';
 import { harnessHooks } from './registry.js';
 import { runHooks } from './run.js';
@@ -10,19 +10,19 @@ export class HookPipeline {
     async onRunStart(payload) {
         const folded = await runHooks(this._behaviorHooks, { phase: 'runStart', ...payload });
         if ('guidance' in folded) {
-            hlog('run hook failed', { stage: 'runStart', error: folded.error });
+            log.warn('run hook failed', { stage: 'runStart', error: folded.error });
         }
     }
     async onRunEnd(payload) {
         const folded = await runHooks(this._behaviorHooks, { phase: 'runEnd', ...payload });
         if ('guidance' in folded) {
-            hlog('run hook failed', { stage: 'runEnd', error: folded.error });
+            log.warn('run hook failed', { stage: 'runEnd', error: folded.error });
         }
     }
     async runPreToolFold(payload) {
         const folded = await runHooks(this._behaviorHooks, { phase: 'preToolCall', ...payload });
         if ('guidance' in folded) {
-            hlog('tool rejected: pre-hook refused the call', { tool: payload.toolName });
+            log.info('tool rejected: pre-hook refused the call', { tool: payload.toolName });
             return { ok: false, rejection: folded };
         }
         return { ok: true, args: folded.args };

package/dist-lib/lib/hooks/run.js

@@ -1,5 +1,5 @@
 import { errorMessage, isRecord } from '../guards.js';
-import { hlog } from '../log.js';
+import { log } from '../log.js';
 function cloneJson(value) {
     try {
         const text = JSON.stringify(value);
@@ -55,7 +55,7 @@ function merge(current, returned) {
 }
 function rejectionOf(current, err) {
     const message = errorMessage(err);
-    hlog('hook failed', { stage: current.phase, error: message });
+    log.warn('hook failed', { stage: current.phase, error: message });
     if (current.phase === 'postToolCall') {
         return {
             error: `tool executed; output withheld: post-hook failed: ${message}. Do not retry this call.`,

package/dist-lib/lib/log.d.ts

@@ -1,5 +1,29 @@
+import { type LogLevel } from '@qvac/logging';
+export type { LogLevel };
+export type LineLevel = Exclude<LogLevel, 'off'>;
+type Write = (message: string, data?: Record<string, unknown>) => void;
+type Sink = (line: string, level: LineLevel) => void;
+export interface HarnessLog {
+    readonly error: Write;
+    readonly warn: Write;
+    readonly info: Write;
+    readonly debug: Write;
+}
+export interface HostLogger {
+    info(...args: unknown[]): void;
+    warn(...args: unknown[]): void;
+    error?(...args: unknown[]): void;
+    debug?(...args: unknown[]): void;
+    getLevel?(): string;
+}
+export declare const log: HarnessLog;
 export declare function setHarnessLog(on: boolean): void;
-export declare function harnessLogEnabled(): boolean;
-export declare function setHarnessLogSink(next: ((line: string) => void) | null): void;
+export declare function setHarnessLogLevel(level: LogLevel): void;
+export declare function followHostLevel(level: unknown): void;
+export declare function logToHost(next: HostLogger | null): void;
+export declare function harnessLogLevel(): LogLevel;
+export declare function isLogLevel(value: unknown): value is LogLevel;
+export declare function logEnabled(level: LineLevel): boolean;
+export declare function setHarnessLogSink(next: Sink | null): void;
 export declare function hlog(message: string, data?: Record<string, unknown>): void;
 export declare function hdiag(message: string, data?: Record<string, unknown>): void;