@principles/core 1.123.0 → 1.125.0

package/dist/runtime-v2/runner/__tests__/start-run-input.test.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-run-input.test.js","sourceRoot":"","sources":["../../../../src/runtime-v2/runner/__tests__/start-run-input.test.ts"],"names":[],"mappings":"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"}

package/dist/runtime-v2/runner/diagnostician-runner-options.d.ts

@@ -1,57 +0,0 @@
-/**
- * Configuration options for DiagnosticianRunner.
- *
- * Per CONTEXT.md D-02: pollIntervalMs default 5000, timeout configurable.
- * Per CONTEXT.md D-04: owner and runtimeKind required for lease acquisition.
- */
-import type { OutputLanguage } from '../language-directive.js';
-import type { EffectivePdConfig } from '../config/pd-config-types.js';
-export interface DiagnosticianRunnerOptions {
-    /** Polling interval in ms (default: 5000 = 5 seconds). */
-    readonly pollIntervalMs?: number;
-    /** Maximum runtime execution time in ms (default: 300000 = 5 minutes). */
-    readonly timeoutMs?: number;
-    /** Default maxAttempts for synthetic TaskRecord in lease error path (default: 3). */
-    readonly defaultMaxAttempts?: number;
-    /** Lease owner identifier for acquireLease. */
-    readonly owner: string;
-    /** RuntimeKind value for lease/run record creation. */
-    readonly runtimeKind: string;
-    /**
-     * Agent ID passed to the runtime adapter (default: 'diagnostician').
-     * Allows CLI to forward --agent flag through to openclaw agent invocation.
-     */
-    readonly agentId?: string;
-    /**
-     * Owner's preferred language for principle generation (PRI-336).
-     * When provided, the diagnostician prompt includes a language directive
-     * telling the LLM to produce human-readable fields in this language.
-     * Undefined = no language directive (backward compatible).
-     */
-    readonly outputLanguage?: OutputLanguage;
-    /**
-     * Effective PD config for feature flag resolution (PRI-371).
-     * When provided, the runner reads `diagnostician_core_grounding` flag
-     * to decide whether to inject core axioms into the prompt.
-     * Undefined = flag off (backward compatible).
-     */
-    readonly effectiveConfig?: EffectivePdConfig;
-}
-/** Resolved options with defaults applied. */
-export interface ResolvedDiagnosticianRunnerOptions {
-    readonly pollIntervalMs: number;
-    readonly timeoutMs: number;
-    readonly defaultMaxAttempts: number;
-    readonly owner: string;
-    readonly runtimeKind: string;
-    readonly agentId: string;
-    /** Owner's preferred language for principle generation (PRI-336). Undefined = no directive. */
-    readonly outputLanguage?: OutputLanguage;
-    /** Effective PD config for feature flag resolution (PRI-371). Undefined = flags off. */
-    readonly effectiveConfig?: EffectivePdConfig;
-}
-/** Default option values. */
-export declare const DEFAULT_RUNNER_OPTIONS: Readonly<Omit<ResolvedDiagnosticianRunnerOptions, 'owner' | 'runtimeKind'>>;
-/** Resolve options by applying defaults. */
-export declare function resolveRunnerOptions(options: DiagnosticianRunnerOptions): ResolvedDiagnosticianRunnerOptions;
-//# sourceMappingURL=diagnostician-runner-options.d.ts.map

package/dist/runtime-v2/runner/diagnostician-runner-options.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostician-runner-options.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/runner/diagnostician-runner-options.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAC/D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEtE,MAAM,WAAW,0BAA0B;IACzC,0DAA0D;IAC1D,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;IACjC,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,qFAAqF;IACrF,QAAQ,CAAC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IACrC,+CAA+C;IAC/C,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,uDAAuD;IACvD,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B;;;;;OAKG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,eAAe,CAAC,EAAE,iBAAiB,CAAC;CAC9C;AAED,8CAA8C;AAC9C,MAAM,WAAW,kCAAkC;IACjD,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,kBAAkB,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,+FAA+F;IAC/F,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC,wFAAwF;IACxF,QAAQ,CAAC,eAAe,CAAC,EAAE,iBAAiB,CAAC;CAC9C;AAED,6BAA6B;AAC7B,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,IAAI,CAAC,kCAAkC,EAAE,OAAO,GAAG,aAAa,CAAC,CAKrG,CAAC;AAEX,4CAA4C;AAC5C,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,0BAA0B,GAAG,kCAAkC,CAW5G"}

package/dist/runtime-v2/runner/diagnostician-runner-options.js

@@ -1,21 +0,0 @@
-/** Default option values. */
-export const DEFAULT_RUNNER_OPTIONS = {
-    pollIntervalMs: 5_000,
-    timeoutMs: 300_000,
-    defaultMaxAttempts: 3,
-    agentId: 'main',
-};
-/** Resolve options by applying defaults. */
-export function resolveRunnerOptions(options) {
-    return {
-        pollIntervalMs: options.pollIntervalMs ?? DEFAULT_RUNNER_OPTIONS.pollIntervalMs,
-        timeoutMs: options.timeoutMs ?? DEFAULT_RUNNER_OPTIONS.timeoutMs,
-        defaultMaxAttempts: options.defaultMaxAttempts ?? DEFAULT_RUNNER_OPTIONS.defaultMaxAttempts,
-        owner: options.owner,
-        runtimeKind: options.runtimeKind,
-        agentId: options.agentId ?? DEFAULT_RUNNER_OPTIONS.agentId,
-        outputLanguage: options.outputLanguage,
-        effectiveConfig: options.effectiveConfig,
-    };
-}
-//# sourceMappingURL=diagnostician-runner-options.js.map

package/dist/runtime-v2/runner/diagnostician-runner-options.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostician-runner-options.js","sourceRoot":"","sources":["../../../src/runtime-v2/runner/diagnostician-runner-options.ts"],"names":[],"mappings":"AAuDA,6BAA6B;AAC7B,MAAM,CAAC,MAAM,sBAAsB,GAAgF;IACjH,cAAc,EAAE,KAAK;IACrB,SAAS,EAAE,OAAO;IAClB,kBAAkB,EAAE,CAAC;IACrB,OAAO,EAAE,MAAM;CACP,CAAC;AAEX,4CAA4C;AAC5C,MAAM,UAAU,oBAAoB,CAAC,OAAmC;IACtE,OAAO;QACL,cAAc,EAAE,OAAO,CAAC,cAAc,IAAI,sBAAsB,CAAC,cAAc;QAC/E,SAAS,EAAE,OAAO,CAAC,SAAS,IAAI,sBAAsB,CAAC,SAAS;QAChE,kBAAkB,EAAE,OAAO,CAAC,kBAAkB,IAAI,sBAAsB,CAAC,kBAAkB;QAC3F,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,WAAW,EAAE,OAAO,CAAC,WAAW;QAChC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,sBAAsB,CAAC,OAAO;QAC1D,cAAc,EAAE,OAAO,CAAC,cAAc;QACtC,eAAe,EAAE,OAAO,CAAC,eAAe;KACzC,CAAC;AACJ,CAAC"}

package/dist/runtime-v2/runner/diagnostician-runner.d.ts

@@ -1,89 +0,0 @@
-/**
- * DiagnosticianRunner -- explicit runner-driven diagnostician execution.
- *
- * Replaces heartbeat-prompt-driven execution with a deterministic pipeline:
- *   lease -> build context -> invoke runtime -> poll -> fetch output -> validate -> succeed/fail
- *
- * Per D-01: Phase-based step pipeline, each phase is independent method.
- * Per D-02: Polling loop with configurable interval and timeout.
- * Per D-03: Retry with backoff on transient errors, fail on permanent.
- * Per D-04: All store operations through RuntimeStateManager.
- *
- * Runner does NOT:
- *   - Import from evolution-worker.ts or prompt.ts
- *   - Write artifact files (M5 scope)
- *   - Emit principle candidates (M5 scope)
- *   - Persist RunnerPhase to TaskStore
- */
-import type { RuntimeStateManager } from '../store/runtime-state-manager.js';
-import type { ContextAssembler } from '../store/context/context-assembler.js';
-import type { PDRuntimeAdapter } from '../runtime-protocol.js';
-import type { StoreEventEmitter } from '../store/event-emitter.js';
-import type { DiagnosticianRunnerOptions } from './diagnostician-runner-options.js';
-import type { DiagnosticianValidator } from './diagnostician-validator.js';
-import type { RunnerResult } from './runner-result.js';
-import type { DiagnosticianCommitter } from '../store/commit/diagnostician-committer.js';
-import { RunnerPhase } from './runner-phase.js';
-/** Dependencies injected into DiagnosticianRunner. */
-export interface DiagnosticianRunnerDeps {
-    readonly stateManager: RuntimeStateManager;
-    readonly contextAssembler: ContextAssembler;
-    readonly runtimeAdapter: PDRuntimeAdapter;
-    readonly eventEmitter: StoreEventEmitter;
-    readonly validator: DiagnosticianValidator;
-    readonly committer: DiagnosticianCommitter;
-}
-export declare class DiagnosticianRunner {
-    private phase;
-    private readonly resolvedOptions;
-    private readonly stateManager;
-    private readonly contextAssembler;
-    private readonly runtimeAdapter;
-    private readonly eventEmitter;
-    private readonly validator;
-    private readonly committer;
-    /** Whether core grounding was active for the current run (set in invokeRuntime, read in succeedTask). */
-    private coreGroundingActive;
-    constructor(deps: DiagnosticianRunnerDeps, options: DiagnosticianRunnerOptions);
-    /** Get the current internal phase. For testing/observability only. */
-    get currentPhase(): RunnerPhase;
-    /**
-     * Emit a diagnostician telemetry event via the store event emitter.
-     */
-    private emitDiagnosticianEvent;
-    /**
-     * Execute the full diagnostician lifecycle for a task.
-     *
-     * The runner does NOT hold mutable state between run() calls.
-     * Each invocation is independent.
-     */
-    run(taskId: string): Promise<RunnerResult>;
-    /**
-     * Handle errors that occur after a successful lease acquisition.
-     * Uses the real leasedTask (with actual attemptCount/maxAttempts) — never synthetic.
-     * lease_conflict is NOT handled here because it cannot occur after a successful lease.
-     */
-    private handlePostLeaseError;
-    private buildContext;
-    /**
-     * Resolve the store's runId for the latest run of a task.
-     * acquireLease creates a RunRecord with a deterministic ID (run_{taskId}_{attempt}).
-     * The adapter's RunHandle.runId is separate -- we need the store's ID for
-     * updateRunOutput and other store operations.
-     */
-    private resolveStoreRunId;
-    private invokeRuntime;
-    private pollUntilTerminal;
-    private fetchAndParseOutput;
-    private succeedTask;
-    private handleRuntimeFailure;
-    private handleValidationError;
-    private handleLeaseOrPhaseError;
-    private retryOrFail;
-    private readonly PERMANENT_ERROR_CATEGORIES;
-    private isPermanentError;
-    private classifyError;
-    private mapRunStatusToErrorCategory;
-    private sleep;
-}
-//# sourceMappingURL=diagnostician-runner.d.ts.map

package/dist/runtime-v2/runner/diagnostician-runner.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"diagnostician-runner.d.ts","sourceRoot":"","sources":["../../../src/runtime-v2/runner/diagnostician-runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uCAAuC,CAAC;AAC9E,OAAO,KAAK,EACV,gBAAgB,EAIjB,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAOnE,OAAO,KAAK,EAAE,0BAA0B,EAAsC,MAAM,mCAAmC,CAAC;AACxH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AAC3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,sBAAsB,EAAgB,MAAM,4CAA4C,CAAC;AAMvG,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAKhD,sDAAsD;AACtD,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,YAAY,EAAE,mBAAmB,CAAC;IAC3C,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C,QAAQ,CAAC,cAAc,EAAE,gBAAgB,CAAC;IAC1C,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;IAC3C,QAAQ,CAAC,SAAS,EAAE,sBAAsB,CAAC;CAC5C;AA2BD,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,KAAK,CAAiC;IAC9C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAqC;IACrE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;IACnD,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmB;IACpD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAmB;IAClD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAyB;IACnD,yGAAyG;IACzG,OAAO,CAAC,mBAAmB,CAAS;gBAExB,IAAI,EAAE,uBAAuB,EAAE,OAAO,EAAE,0BAA0B;IAU9E,sEAAsE;IACtE,IAAI,YAAY,IAAI,WAAW,CAE9B;IAED;;OAEG;IACH,OAAO,CAAC,sBAAsB;IAe9B;;;;;OAKG;IACG,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;IAqFhD;;;;OAIG;YACW,oBAAoB;YAoBpB,YAAY;IAI1B;;;;;OAKG;YACW,iBAAiB;YASjB,aAAa;YAyBb,iBAAiB;YAyBjB,mBAAmB;YAqCnB,WAAW;YAsHX,oBAAoB;YAgBpB,qBAAqB;YAkBrB,uBAAuB;YAyCvB,WAAW;IA4CzB,OAAO,CAAC,QAAQ,CAAC,0BAA0B,CAEzC;IAEF,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,2BAA2B;IAUnC,OAAO,CAAC,KAAK;CAGd"}

package/dist/runtime-v2/runner/diagnostician-runner.js

@@ -1,470 +0,0 @@
-import { DiagnosticianOutputV1Schema } from '../diagnostician-output.js';
-import { DiagnosticianPromptBuilder } from '../diagnostician-prompt-builder.js';
-import { PDRuntimeError } from '../error-categories.js';
-import { Value } from '@sinclair/typebox/value';
-import { safeStringifyPreview } from '../adapter/output-repair-contract.js';
-import { redactSensitiveFields } from '../feedback/redact-sensitive.js';
-import { RunnerPhase } from './runner-phase.js';
-import { resolveRunnerOptions } from './diagnostician-runner-options.js';
-import { computeFeatureFlagsFromConfig, isFeatureEnabled } from '../config/pd-config-feature-flags.js';
-import { CORE_PRINCIPLES, isCorePrincipleId } from '../core-principles/core-principle-registry.js';
-export class DiagnosticianRunner {
-    phase = RunnerPhase.Idle;
-    resolvedOptions;
-    stateManager;
-    contextAssembler;
-    runtimeAdapter;
-    eventEmitter;
-    validator;
-    committer;
-    /** Whether core grounding was active for the current run (set in invokeRuntime, read in succeedTask). */
-    coreGroundingActive = false;
-    constructor(deps, options) {
-        this.stateManager = deps.stateManager;
-        this.contextAssembler = deps.contextAssembler;
-        this.runtimeAdapter = deps.runtimeAdapter;
-        this.eventEmitter = deps.eventEmitter;
-        this.validator = deps.validator;
-        this.committer = deps.committer;
-        this.resolvedOptions = resolveRunnerOptions(options);
-    }
-    /** Get the current internal phase. For testing/observability only. */
-    get currentPhase() {
-        return this.phase;
-    }
-    /**
-     * Emit a diagnostician telemetry event via the store event emitter.
-     */
-    emitDiagnosticianEvent(eventType, taskId, payload) {
-        this.eventEmitter.emitTelemetry({
-            eventType: eventType,
-            traceId: taskId,
-            timestamp: new Date().toISOString(),
-            sessionId: this.resolvedOptions.owner,
-            agentId: this.resolvedOptions.agentId,
-            payload,
-        });
-    }
-    /**
-     * Execute the full diagnostician lifecycle for a task.
-     *
-     * The runner does NOT hold mutable state between run() calls.
-     * Each invocation is independent.
-     */
-    async run(taskId) {
-        this.phase = RunnerPhase.Idle;
-        this.coreGroundingActive = false;
-        // 1. Acquire lease — isolated try/catch so lease_conflict never uses synthetic TaskRecord
-        let leasedTask;
-        try {
-            leasedTask = await this.stateManager.acquireLease({
-                taskId,
-                owner: this.resolvedOptions.owner,
-                runtimeKind: this.resolvedOptions.runtimeKind,
-            });
-        }
-        catch (error) {
-            return await this.handleLeaseOrPhaseError(taskId, error);
-        }
-        // Emit: diagnostician_task_leased (only on successful lease)
-        this.emitDiagnosticianEvent('diagnostician_task_leased', taskId, {
-            taskKind: leasedTask.taskKind,
-            attemptCount: leasedTask.attemptCount,
-        });
-        // All subsequent errors use the real leasedTask — no synthetic TaskRecord allowed
-        try {
-            // Look up the store's runId for this attempt (acquireLease creates it).
-            // The adapter's RunHandle.runId is separate from the store's runId.
-            const storeRunId = await this.resolveStoreRunId(taskId);
-            // 2. Build context
-            this.phase = RunnerPhase.BuildingContext;
-            const context = await this.buildContext(taskId);
-            const contextHash = context.contextHash;
-            // Emit: diagnostician_context_built
-            this.emitDiagnosticianEvent('diagnostician_context_built', taskId, {
-                contextHash,
-                sourceCount: context.sourceRefs.length,
-            });
-            // 3. Invoke runtime (skip CreatingRun -- acquireLease already created it)
-            this.phase = RunnerPhase.Invoking;
-            const runHandle = await this.invokeRuntime(context, taskId);
-            // Emit: diagnostician_run_started
-            this.emitDiagnosticianEvent('diagnostician_run_started', taskId, {
-                runtimeKind: this.resolvedOptions.runtimeKind,
-            });
-            // 4. Poll until terminal
-            this.phase = RunnerPhase.Polling;
-            const finalStatus = await this.pollUntilTerminal(runHandle);
-            // 5. Handle non-success terminal states
-            if (finalStatus.status !== 'succeeded') {
-                return await this.handleRuntimeFailure(taskId, leasedTask, finalStatus);
-            }
-            // 6. Fetch output
-            this.phase = RunnerPhase.FetchingOutput;
-            const output = await this.fetchAndParseOutput(runHandle.runId);
-            // 7. Validate (delegate to validator)
-            this.phase = RunnerPhase.Validating;
-            const validationResult = await this.validator.validate(output, taskId);
-            if (!validationResult.valid) {
-                return await this.handleValidationError({
-                    taskId, task: leasedTask, errors: validationResult.errors, errorCategory: validationResult.errorCategory,
-                });
-            }
-            // TELE-04: output_validation_succeeded — validator returned valid: true
-            this.emitDiagnosticianEvent('output_validation_succeeded', taskId, {
-                runtimeKind: this.resolvedOptions.runtimeKind,
-                outputValid: validationResult.valid,
-            });
-            // 8. Succeed task -- store output and mark succeeded using store's runId
-            return await this.succeedTask({ taskId, runId: storeRunId, output, task: leasedTask, contextHash });
-        }
-        catch (error) {
-            // handleLeaseOrPhaseError is only used for lease errors (before lease).
-            // Post-lease errors use retryOrFail with the real leasedTask.
-            return await this.handlePostLeaseError(taskId, leasedTask, error);
-        }
-    }
-    /**
-     * Handle errors that occur after a successful lease acquisition.
-     * Uses the real leasedTask (with actual attemptCount/maxAttempts) — never synthetic.
-     * lease_conflict is NOT handled here because it cannot occur after a successful lease.
-     */
-    async handlePostLeaseError(taskId, task, error) {
-        const classified = this.classifyError(error);
-        // Emit: diagnostician_run_failed
-        this.emitDiagnosticianEvent('diagnostician_run_failed', taskId, {
-            errorCategory: classified.category,
-            errorMessage: classified.message,
-        });
-        // Post-lease errors always go through retryOrFail with the real task record.
-        // This ensures attemptCount/maxAttempts from the store are respected.
-        return this.retryOrFail({ taskId, task, errorCategory: classified.category, failureReason: classified.message });
-    }
-    // -- Phase methods (each independently testable) --
-    async buildContext(taskId) {
-        return this.contextAssembler.assemble(taskId);
-    }
-    /**
-     * Resolve the store's runId for the latest run of a task.
-     * acquireLease creates a RunRecord with a deterministic ID (run_{taskId}_{attempt}).
-     * The adapter's RunHandle.runId is separate -- we need the store's ID for
-     * updateRunOutput and other store operations.
-     */
-    async resolveStoreRunId(taskId) {
-        const runs = await this.stateManager.getRunsByTask(taskId);
-        const latestRun = runs[runs.length - 1];
-        if (!latestRun) {
-            throw new PDRuntimeError('execution_failed', `No run record found for task ${taskId} after lease acquisition`);
-        }
-        return latestRun.runId;
-    }
-    async invokeRuntime(context, taskId) {
-        // T-E (PRI-371): Read diagnostician_core_grounding flag from effective config.
-        // EP-03: Flag off (default) = no change to prompt. Flag on = inject PHASE 3.5.
-        let coreGrounding = false;
-        if (this.resolvedOptions.effectiveConfig) {
-            const featureFlags = computeFeatureFlagsFromConfig(this.resolvedOptions.effectiveConfig);
-            coreGrounding = isFeatureEnabled(featureFlags, 'diagnostician_core_grounding');
-        }
-        this.coreGroundingActive = coreGrounding;
-        const builder = new DiagnosticianPromptBuilder();
-        const { message } = builder.buildPrompt(context, { outputLanguage: this.resolvedOptions.outputLanguage, coreGrounding });
-        const startInput = {
-            agentSpec: { agentId: this.resolvedOptions.agentId, schemaVersion: 'v1' },
-            taskRef: { taskId },
-            inputPayload: message,
-            contextItems: [],
-            outputSchemaRef: 'diagnostician-output-v1',
-            timeoutMs: this.resolvedOptions.timeoutMs,
-        };
-        return this.runtimeAdapter.startRun(startInput);
-    }
-    async pollUntilTerminal(runHandle) {
-        const deadline = Date.now() + this.resolvedOptions.timeoutMs;
-        const terminalStatuses = ['succeeded', 'failed', 'timed_out', 'cancelled'];
-        while (Date.now() < deadline) {
-            const status = await this.runtimeAdapter.pollRun(runHandle.runId);
-            if (terminalStatuses.includes(status.status)) {
-                return status;
-            }
-            await this.sleep(this.resolvedOptions.pollIntervalMs);
-        }
-        // Timeout -- cancel the run gracefully, preserving the timeout error
-        try {
-            await this.runtimeAdapter.cancelRun(runHandle.runId);
-        }
-        catch (cancelErr) {
-            // Log but do not throw — timeout error is the primary failure to report
-            this.emitDiagnosticianEvent('diagnostician_cancel_run_failed', 'timeout-task', {
-                runId: runHandle.runId,
-                errorMessage: cancelErr instanceof Error ? cancelErr.message : String(cancelErr),
-            });
-        }
-        throw new PDRuntimeError('timeout', `Run ${runHandle.runId} timed out after ${this.resolvedOptions.timeoutMs}ms`);
-    }
-    async fetchAndParseOutput(runId) {
-        const result = await this.runtimeAdapter.fetchOutput(runId);
-        if (!result || !result.payload) {
-            throw new PDRuntimeError('output_invalid', `No output available for run ${runId}`);
-        }
-        // ERR-001/ERR-005: Do NOT use `as DiagnosticianOutputV1` to bypass validation.
-        // The adapter may return payload that passed its own schema check, but the runner
-        // must independently verify the shape before trusting it (defense-in-depth).
-        // Adapters that already validated (e.g., PiAiRuntimeAdapter, OpenClawCliRuntimeAdapter)
-        // will pass this check trivially; adapters that don't validate will be caught here.
-        if (!Value.Check(DiagnosticianOutputV1Schema, result.payload)) {
-            const schemaErrors = [...Value.Errors(DiagnosticianOutputV1Schema, result.payload)]
-                .slice(0, 5)
-                .map(e => ({ path: e.path, message: e.message }));
-            const redacted = redactSensitiveFields(result.payload);
-            const boundedPreview = redacted.ok
-                ? safeStringifyPreview(redacted.value, 300)
-                : safeStringifyPreview(result.payload, 300);
-            throw new PDRuntimeError('output_invalid', `Run ${runId} output failed DiagnosticianOutputV1 schema validation at runner boundary`, {
-                parseFailureReason: 'runner_boundary_schema_check_failed',
-                boundedRawOutputPreview: boundedPreview,
-                schemaErrors,
-                nextAction: 'Adapter returned payload that does not match DiagnosticianOutputV1; check adapter validation logic',
-            });
-        }
-        // Value.Check narrows the type at runtime but not in TS; Value.Cast
-        // performs a safe conversion after validation passes.
-        return Value.Cast(DiagnosticianOutputV1Schema, result.payload);
-    }
-    async succeedTask(ctx) {
-        // Lineage strip contract invariant: adapter should have stripped lineage
-        // fields (taskId, sourcePainId, etc.) from LLM output. If they survive,
-        // the adapter violated its contract — emit telemetry but don't crash.
-        const outputRecord = ctx.output;
-        if (typeof outputRecord === 'object' && outputRecord !== null &&
-            Object.hasOwn(outputRecord, 'taskId')) {
-            this.emitDiagnosticianEvent('lineage_strip_contract_violation', ctx.taskId, {
-                reason: 'output_contained_taskId_after_strip',
-                expectedAdapter: 'pi-ai-runtime-adapter',
-            });
-        }
-        // Store output before commit so run record reflects output on disk
-        try {
-            await this.stateManager.updateRunOutput(ctx.runId, JSON.stringify(ctx.output));
-        }
-        catch (updateErr) {
-            this.emitDiagnosticianEvent('diagnostician_update_output_failed', ctx.taskId, {
-                runId: ctx.runId,
-                errorMessage: updateErr instanceof Error ? updateErr.message : String(updateErr),
-            });
-            throw updateErr;
-        }
-        // Commit artifact + candidates before marking task succeeded
-        this.phase = RunnerPhase.Committing;
-        let commitResult;
-        try {
-            commitResult = await this.committer.commit({
-                runId: ctx.runId,
-                taskId: ctx.taskId,
-                output: ctx.output,
-                idempotencyKey: `${ctx.taskId}:${ctx.runId}`,
-            });
-        }
-        catch (commitErr) {
-            // Emit: diagnostician_artifact_commit_failed (TELE-02)
-            this.emitDiagnosticianEvent('diagnostician_artifact_commit_failed', ctx.taskId, {
-                taskId: ctx.taskId,
-                runId: ctx.runId,
-                errorCategory: commitErr instanceof PDRuntimeError ? commitErr.category : 'artifact_commit_failed',
-                errorMessage: commitErr instanceof Error ? commitErr.message : String(commitErr),
-            });
-            throw commitErr; // Re-throw so outer try/catch in run() handles it
-        }
-        // Emit: principle_candidate_registered per candidate (TELE-03)
-        const principleRecs = ctx.output.recommendations.filter((r) => r.kind === 'principle');
-        for (let i = 0; i < principleRecs.length; i++) {
-            const rec = principleRecs[i]; // eslint-disable-line @typescript-eslint/no-non-null-assertion
-            this.emitDiagnosticianEvent('principle_candidate_registered', ctx.taskId, {
-                candidateIndex: i,
-                commitId: commitResult.commitId,
-                kind: 'principle',
-                description: rec.description,
-                sourceRunId: ctx.runId,
-            });
-        }
-        // Emit: diagnostician_artifact_committed (TELE-01)
-        this.emitDiagnosticianEvent('diagnostician_artifact_committed', ctx.taskId, {
-            commitId: commitResult.commitId,
-            artifactId: commitResult.artifactId,
-            candidateCount: commitResult.candidateCount,
-            taskId: ctx.taskId,
-            runId: ctx.runId,
-        });
-        // Use commit URI as resultRef
-        const resultRef = `commit://${commitResult.commitId}`;
-        try {
-            await this.stateManager.markTaskSucceeded(ctx.taskId, resultRef);
-        }
-        catch (stateErr) {
-            // markTaskSucceeded failed after commit succeeded — emit error event so this is observable
-            this.emitDiagnosticianEvent('diagnostician_mark_succeeded_failed', ctx.taskId, {
-                taskId: ctx.taskId,
-                runId: ctx.runId,
-                commitId: commitResult.commitId,
-                errorMessage: stateErr instanceof Error ? stateErr.message : String(stateErr),
-            });
-            throw stateErr;
-        }
-        // Emit: diagnostician_task_succeeded
-        this.emitDiagnosticianEvent('diagnostician_task_succeeded', ctx.taskId, {
-            attemptCount: ctx.task.attemptCount,
-            resultRef,
-            commitId: commitResult.commitId,
-            candidateCount: commitResult.candidateCount,
-        });
-        // T-E (PRI-371): Emit core grounding telemetry when flag was on.
-        // EP-01: axiom IDs from ambiguityNotes are untrusted LLM output —
-        // validate with regex + isCorePrincipleId() before counting.
-        if (this.coreGroundingActive) {
-            const ambiguityNotes = ctx.output.ambiguityNotes ?? [];
-            const allNotes = ambiguityNotes.join(' ');
-            const axiomIdMatches = allNotes.match(/T-\d{2}/g) ?? [];
-            const validatedIds = axiomIdMatches.filter(id => isCorePrincipleId(id));
-            const uniqueIds = new Set(validatedIds);
-            const linkagePercent = (uniqueIds.size / CORE_PRINCIPLES.length) * 100;
-            this.emitDiagnosticianEvent('diagnostician_core_grounding_result', ctx.taskId, {
-                taskId: ctx.taskId,
-                axiomRefCount: uniqueIds.size,
-                linkagePercent,
-            });
-        }
-        this.phase = RunnerPhase.Completed;
-        return {
-            status: 'succeeded',
-            taskId: ctx.taskId,
-            contextHash: ctx.contextHash,
-            output: ctx.output,
-            attemptCount: ctx.task.attemptCount,
-        };
-    }
-    async handleRuntimeFailure(taskId, task, runStatus) {
-        const errorCategory = this.mapRunStatusToErrorCategory(runStatus.status, runStatus.reason);
-        // Emit: diagnostician_run_failed
-        this.emitDiagnosticianEvent('diagnostician_run_failed', taskId, {
-            runStatus: runStatus.status,
-            errorCategory,
-        });
-        return this.retryOrFail({ taskId, task, errorCategory, failureReason: `Runtime execution ended with status: ${runStatus.status}` });
-    }
-    async handleValidationError(ctx) {
-        const category = ctx.errorCategory ?? 'output_invalid';
-        // Emit: diagnostician_output_invalid
-        this.emitDiagnosticianEvent('diagnostician_output_invalid', ctx.taskId, {
-            errorCount: ctx.errors.length,
-            errorCategory: category,
-        });
-        // TELE-04: output_validation_failed — validator returned valid: false
-        this.emitDiagnosticianEvent('output_validation_failed', ctx.taskId, {
-            errorCount: ctx.errors.length,
-            errorCategory: category,
-        });
-        return this.retryOrFail({ taskId: ctx.taskId, task: ctx.task, errorCategory: category, failureReason: `Validation failed: ${ctx.errors.join('; ')}` });
-    }
-    async handleLeaseOrPhaseError(taskId, error) {
-        const classified = this.classifyError(error);
-        // lease_conflict is a concurrent-access conflict, not a state change.
-        // No mutation methods (markTaskFailed/markTaskRetryWait) are called.
-        if (classified.category === 'lease_conflict') {
-            this.emitDiagnosticianEvent('diagnostician_run_failed', taskId, {
-                errorCategory: 'lease_conflict',
-                errorMessage: classified.message,
-            });
-            return {
-                status: 'failed',
-                taskId,
-                errorCategory: 'lease_conflict',
-                failureReason: classified.message,
-                attemptCount: 1,
-            };
-        }
-        // Non-lease errors (e.g. storage_unavailable before lease) also must not
-        // use synthetic TaskRecord. Build one with real defaults from options.
-        this.emitDiagnosticianEvent('diagnostician_run_failed', taskId, {
-            errorCategory: classified.category,
-            errorMessage: classified.message,
-        });
-        const task = {
-            taskId,
-            taskKind: 'diagnostician',
-            status: 'leased',
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-            attemptCount: 1,
-            maxAttempts: this.resolvedOptions.defaultMaxAttempts,
-        };
-        return this.retryOrFail({ taskId, task, errorCategory: classified.category, failureReason: classified.message });
-    }
-    async retryOrFail(ctx) {
-        // Check if error is permanent (never retry)
-        if (this.isPermanentError(ctx.errorCategory)) {
-            await this.stateManager.markTaskFailed(ctx.taskId, ctx.errorCategory);
-            this.emitDiagnosticianEvent('diagnostician_task_failed', ctx.taskId, {
-                errorCategory: ctx.errorCategory,
-                attemptCount: ctx.task.attemptCount,
-                failureReason: ctx.failureReason,
-            });
-            this.phase = RunnerPhase.Failed;
-            return { status: 'failed', taskId: ctx.taskId, errorCategory: ctx.errorCategory, failureReason: ctx.failureReason, attemptCount: ctx.task.attemptCount };
-        }
-        // Check retry policy
-        const shouldRetry = this.stateManager.getRetryPolicy().shouldRetry(ctx.task);
-        if (shouldRetry) {
-            await this.stateManager.markTaskRetryWait(ctx.taskId, ctx.errorCategory);
-            this.emitDiagnosticianEvent('diagnostician_task_retried', ctx.taskId, {
-                errorCategory: ctx.errorCategory,
-                attemptCount: ctx.task.attemptCount,
-            });
-            this.phase = RunnerPhase.RetryWaiting;
-            return { status: 'retried', taskId: ctx.taskId, errorCategory: ctx.errorCategory, failureReason: ctx.failureReason, attemptCount: ctx.task.attemptCount };
-        }
-        // Max attempts exceeded
-        await this.stateManager.markTaskFailed(ctx.taskId, 'max_attempts_exceeded');
-        this.emitDiagnosticianEvent('diagnostician_task_failed', ctx.taskId, {
-            errorCategory: 'max_attempts_exceeded',
-            attemptCount: ctx.task.attemptCount,
-            failureReason: `Max attempts exceeded: ${ctx.failureReason}`,
-        });
-        this.phase = RunnerPhase.Failed;
-        return {
-            status: 'failed',
-            taskId: ctx.taskId,
-            errorCategory: 'max_attempts_exceeded',
-            failureReason: `Max attempts exceeded: ${ctx.failureReason}`,
-            attemptCount: ctx.task.attemptCount,
-        };
-    }
-    // -- Error classification --
-    PERMANENT_ERROR_CATEGORIES = new Set(Object.freeze(['storage_unavailable', 'workspace_invalid', 'workspace_dirty', 'capability_missing']));
-    isPermanentError(category) {
-        return this.PERMANENT_ERROR_CATEGORIES.has(category);
-    }
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    classifyError(error) {
-        if (error instanceof PDRuntimeError) {
-            return { category: error.category, message: error.message };
-        }
-        if (error instanceof Error) {
-            return { category: 'execution_failed', message: error.message };
-        }
-        return { category: 'execution_failed', message: String(error) };
-    }
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    mapRunStatusToErrorCategory(status, _reason) {
-        switch (status) {
-            case 'failed': return 'execution_failed';
-            case 'timed_out': return 'timeout';
-            case 'cancelled': return 'cancelled';
-            default: return 'execution_failed';
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/class-methods-use-this
-    sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-    }
-}
-//# sourceMappingURL=diagnostician-runner.js.map