principles-disciple 1.72.0 → 1.74.0

package/src/core/pain-diagnostic-gate.ts

@@ -0,0 +1,154 @@
+import { SystemLogger } from './system-logger.js';
+
+const PAIN_DIAGNOSTIC_SOURCES = [
+  'manual',
+  'tool_failure',
+  'dispatch_error',
+  'gate_blocked',
+  'user_empathy',
+  'llm_paralysis',
+  'semantic',
+  'subagent_error',
+] as const;
+
+export type PainDiagnosticSource = typeof PAIN_DIAGNOSTIC_SOURCES[number];
+
+export type PainDiagnosticGateReason =
+  | 'manual'
+  | 'high_gfi'
+  | 'repeated_failure'
+  | 'semantic_pain'
+  | 'llm_paralysis'
+  | 'risky_high_score'
+  | 'subagent_error'
+  | 'gate_blocked'
+  | 'cooldown'
+  | 'below_gate';
+
+export interface PainDiagnosticGateInput {
+  source: PainDiagnosticSource | string;
+  score: number;
+  currentGfi: number;
+  consecutiveErrors?: number;
+  isRisky?: boolean;
+  errorHash?: string;
+  sessionId?: string;
+  nowMs?: number;
+  cooldownMs?: number;
+  thresholds?: {
+    painTrigger?: number;
+    highSeverity?: number;
+    highGfi?: number;
+    repeatedFailure?: number;
+    semanticPain?: number;
+  };
+}
+
+export interface PainDiagnosticGateDecision {
+  shouldDiagnose: boolean;
+  reason: PainDiagnosticGateReason;
+  episodeKey: string;
+  detail: string;
+}
+
+const DEFAULT_COOLDOWN_MS = 15 * 60 * 1000;
+const lastDiagnosedAtByEpisode = new Map<string, number>();
+
+function normalizedSource(source: string): PainDiagnosticSource | string {
+  if (source.startsWith('llm_') && source !== 'llm_paralysis') {
+    return 'semantic';
+  }
+  if (!(PAIN_DIAGNOSTIC_SOURCES as readonly string[]).includes(source)) {
+    SystemLogger.log('', 'GATE_UNKNOWN_SOURCE', `Unknown pain source: "${source}"`);
+  }
+  return source;
+}
+
+function buildEpisodeKey(input: PainDiagnosticGateInput): string {
+  const source = normalizedSource(input.source);
+  const sessionId = input.sessionId || 'unknown';
+  const hash = input.errorHash || 'no-hash';
+  return `${sessionId}:${source}:${hash}`;
+}
+
+function withinCooldown(input: PainDiagnosticGateInput, episodeKey: string): boolean {
+  const cooldownMs = input.cooldownMs ?? DEFAULT_COOLDOWN_MS;
+  if (cooldownMs <= 0) return false;
+
+  const nowMs = input.nowMs ?? Date.now();
+  const last = lastDiagnosedAtByEpisode.get(episodeKey);
+  return last !== undefined && nowMs - last < cooldownMs;
+}
+
+function markDiagnosed(input: PainDiagnosticGateInput, episodeKey: string): void {
+  lastDiagnosedAtByEpisode.set(episodeKey, input.nowMs ?? Date.now());
+}
+
+export function resetPainDiagnosticGateForTest(): void {
+  lastDiagnosedAtByEpisode.clear();
+}
+
+export function evaluatePainDiagnosticGate(input: PainDiagnosticGateInput): PainDiagnosticGateDecision {
+  const source = normalizedSource(input.source);
+  const episodeKey = buildEpisodeKey(input);
+  const painTrigger = input.thresholds?.painTrigger ?? 40;
+  const highSeverity = input.thresholds?.highSeverity ?? 70;
+  const highGfi = input.thresholds?.highGfi ?? Math.max(highSeverity, painTrigger + 30);
+  const repeatedFailure = input.thresholds?.repeatedFailure ?? 4;
+  const semanticPain = input.thresholds?.semanticPain ?? Math.max(painTrigger, 60);
+  const score = Number.isFinite(input.score) ? input.score : 0;
+  const currentGfi = Number.isFinite(input.currentGfi) ? input.currentGfi : 0;
+  const consecutiveErrors: number = Number.isFinite(input.consecutiveErrors) ? (input.consecutiveErrors as number) : 0;
+
+  const approve = (reason: PainDiagnosticGateReason, detail: string): PainDiagnosticGateDecision => {
+    if (withinCooldown(input, episodeKey)) {
+      return {
+        shouldDiagnose: false,
+        reason: 'cooldown',
+        episodeKey,
+        detail: `recently diagnosed; ${detail}`,
+      };
+    }
+    markDiagnosed(input, episodeKey);
+    return { shouldDiagnose: true, reason, episodeKey, detail };
+  };
+
+  if (source === 'manual') {
+    return approve('manual', 'manual pain signal bypasses automatic gate');
+  }
+
+  if (source === 'subagent_error' && score >= painTrigger) {
+    return approve('subagent_error', `subagent error score ${score} >= ${painTrigger}`);
+  }
+
+  if (source === 'llm_paralysis' && score >= painTrigger) {
+    return approve('llm_paralysis', `llm paralysis score ${score} >= ${painTrigger}`);
+  }
+
+  if (source === 'gate_blocked' && score >= painTrigger) {
+    return approve('gate_blocked', `gate blocked score ${score} >= ${painTrigger}`);
+  }
+
+  if ((source === 'user_empathy' || source === 'semantic') && score >= semanticPain) {
+    return approve('semantic_pain', `semantic pain score ${score} >= ${semanticPain}`);
+  }
+
+  if (input.isRisky === true && score >= highSeverity) {
+    return approve('risky_high_score', `risky operation score ${score} >= ${highSeverity}`);
+  }
+
+  if (consecutiveErrors >= repeatedFailure) {
+    return approve('repeated_failure', `consecutive errors ${consecutiveErrors} >= ${repeatedFailure}`);
+  }
+
+  if (currentGfi >= highGfi) {
+    return approve('high_gfi', `GFI ${currentGfi.toFixed(1)} >= ${highGfi}`);
+  }
+
+  return {
+    shouldDiagnose: false,
+    reason: 'below_gate',
+    episodeKey,
+    detail: `score=${score}; gfi=${currentGfi.toFixed(1)}; consecutive=${consecutiveErrors}`,
+  };
+}

package/src/core/pain-signal.ts

@@ -1,139 +1,22 @@
-/**
- * Universal PainSignal schema for the Evolution SDK.
- *
- * This module defines a framework-agnostic pain signal that any AI agent
- * framework can produce. It extends the existing PainFlagData format with
- * additional structured fields (domain, severity, context) needed for
- * cross-workspace evolution and multi-domain support.
- *
- * Validation uses @sinclair/typebox to match existing project patterns.
- */
-import { Type, type Static } from '@sinclair/typebox';
-import { Value } from '@sinclair/typebox/value';
+import {
+  type PainSeverity as CorePainSeverity,
+  type PainSignal as CorePainSignal,
+  type PainSignalValidationResult as CorePainSignalValidationResult,
+  PainSeveritySchema,
+  PainSignalSchema,
+  deriveSeverity,
+  validatePainSignal,
+} from '@principles/core/runtime-v2';
+
+export type PainSeverity = CorePainSeverity;
+export const PainSeverity = PainSeveritySchema;
+
+export type PainSignal = CorePainSignal;
+export type PainSignalValidationResult = CorePainSignalValidationResult;
+
+export {
+  PainSignalSchema,
+  deriveSeverity,
+  validatePainSignal,
+};
 
-// ---------------------------------------------------------------------------
-// PainSignal Schema
-// ---------------------------------------------------------------------------
-
-/**
- * Severity levels derived from pain score thresholds.
- * - low:      0-39  (minor issue, informational)
- * - medium:   40-69 (moderate error)
- * - high:     70-89 (severe violation)
- * - critical: 90-100 (systemic failure, spiral detected)
- */
-export const PainSeverity = Type.Union([
-  Type.Literal('low'),
-  Type.Literal('medium'),
-  Type.Literal('high'),
-  Type.Literal('critical'),
-]);
-
-export type PainSeverity = Static<typeof PainSeverity>;
-
-/**
- * TypeBox schema for a universal pain signal.
- *
- * Every signal MUST have: source, score, timestamp, reason, sessionId,
- * agentId, traceId, triggerTextPreview. Optional fields (domain, severity,
- * context) default during validation.
- */
-export const PainSignalSchema = Type.Object({
-  /** What triggered this pain signal (e.g., 'tool_failure', 'human_intervention') */
-  source: Type.String({ minLength: 1 }),
-  /** Pain score 0-100 */
-  score: Type.Number({ minimum: 0, maximum: 100 }),
-  /** ISO 8601 timestamp */
-  timestamp: Type.String({ minLength: 1 }),
-  /** Human-readable reason / error description */
-  reason: Type.String({ minLength: 1 }),
-  /** Session ID — identifies which conversation this happened in */
-  sessionId: Type.Optional(Type.String()),
-  /** Agent ID — identifies which agent (main, builder, diagnostician, etc.) */
-  agentId: Type.Optional(Type.String()),
-  /** Correlation trace ID for linking events across the pipeline */
-  traceId: Type.Optional(Type.String()),
-  /** Preview of the text that triggered this pain */
-  triggerTextPreview: Type.String(),
-  /** Domain context (e.g., 'coding', 'writing', 'analysis') */
-  domain: Type.String({ default: 'coding' }),
-  /** Severity level derived from score */
-  severity: PainSeverity,
-  /** Additional structured context payload */
-  context: Type.Record(Type.String(), Type.Unknown()),
-});
-
-export type PainSignal = Static<typeof PainSignalSchema>;
-
-// ---------------------------------------------------------------------------
-// Default Derivation
-// ---------------------------------------------------------------------------
-
-/**
- * Derives severity from a numeric pain score.
- */
-export function deriveSeverity(score: number): PainSeverity {
-  if (score >= 90) return 'critical';
-  if (score >= 70) return 'high';
-  if (score >= 40) return 'medium';
-  return 'low';
-}
-
-// ---------------------------------------------------------------------------
-// Validation
-// ---------------------------------------------------------------------------
-
-export interface PainSignalValidationResult {
-  valid: boolean;
-  errors: string[];
-  signal?: PainSignal;
-}
-
-/**
- * Validates an arbitrary object against the PainSignal schema.
- *
- * Returns a structured result with:
- * - `valid`: whether the input conforms to the schema
- * - `errors`: human-readable list of validation failures
- * - `signal`: the typed signal (only present when valid)
- *
- * Missing optional fields (domain, severity, context) are filled with defaults
- * before validation so callers get a fully-formed signal back.
- */
-export function validatePainSignal(input: unknown): PainSignalValidationResult {
-  if (typeof input !== 'object' || input === null || Array.isArray(input)) {
-    return { valid: false, errors: ['Input must be a non-null object'] };
-  }
-
-  const raw = input as Record<string, unknown>;
-
-  // Apply defaults for optional fields before validation
-  const hydrated = {
-    ...raw,
-    domain: raw.domain ?? 'coding',
-    sessionId: raw.sessionId ?? undefined,
-    agentId: raw.agentId ?? undefined,
-    traceId: raw.traceId ?? undefined,
-    severity: raw.severity ?? deriveSeverity(
-      typeof raw.score === 'number' ? raw.score : 0,
-    ),
-    context: raw.context ?? {},
-  };
-
-  // Collect TypeBox errors
-  const errors = [...Value.Errors(PainSignalSchema, hydrated)];
-  if (errors.length > 0) {
-    return {
-      valid: false,
-      errors: errors.map(
-        (e) => `${e.path ? `${e.path}: ` : ''}${e.message}`,
-      ),
-    };
-  }
-
-  return {
-    valid: true,
-    errors: [],
-    signal: Value.Cast(PainSignalSchema, hydrated) as PainSignal,
-  };
-}

package/src/core/pain.ts

@@ -1,16 +1,18 @@
 import * as fs from 'fs';
-import * as path from 'path';
-import { serializeKvLines, parseKvLines, atomicWriteFileSync } from '../utils/io.js';
+import { parseKvLines } from '../utils/io.js';
 import { resolvePdPath } from './paths.js';
 import { ConfigService } from './config-service.js';
 import { SystemLogger } from './system-logger.js';
 
 // =========================================================================
-// Pain Flag Contract (Single Source of Truth)
+// Legacy Pain Flag Contract (Compatibility Only)
 //
-// All pain flag writers MUST use buildPainFlag() below.
-// If you need to add a new field, update this type AND buildPainFlag().
-// This prevents format drift across the 5+ pain signal sources.
+// Runtime V2 pain diagnosis does NOT write .state/.pain_flag or consume it as
+// an entry point. New pain signals must enter through emitPainDetectedEvent() or
+// `pd pain record`, which both route to PainSignalBridge.
+//
+// The readers below remain only for legacy sleep-reflection context and
+// historical state inspection. They must not trigger the diagnostician.
 // =========================================================================
 
 /**
@@ -47,15 +49,8 @@ export interface PainFlagContractResult {
 }
 
 /**
- * Factory function — the ONLY way to construct pain flag data.
- *
- * All callers (hooks/pain.ts, hooks/subagent.ts, hooks/lifecycle.ts,
- * hooks/llm.ts, skills/pain/SKILL.md) must go through this function.
- *
- * Required fields are enforced by TypeScript — you can't compile
- * without providing source, score, time, reason, session_id, agent_id.
- *
- * Optional fields (trace_id, trigger_text_preview) default to empty string.
+ * Builds legacy pain flag data for compatibility tests and historical readers.
+ * Do not use this to create new Runtime V2 diagnosis requests.
  */
 export function buildPainFlag(input: {
   source: string;
@@ -153,71 +148,6 @@ export function painSeverityLabel(painScore: number, isSpiral = false, projectDi
   }
 }
 
-export function writePainFlag(projectDir: string, painData: PainFlagData): void {
-  const painFlagPath = resolvePdPath(projectDir, 'PAIN_FLAG');
-  const dir = path.dirname(painFlagPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  atomicWriteFileSync(painFlagPath, serializeKvLines(painData));
-}
-
-/**
- * Combined trajectory record + pain flag write.
- *
- * Records the pain event to trajectory first to get the AUTOINCREMENT ID,
- * then builds and writes the pain flag with that ID embedded.
- * This guarantees the pain→principle→compile chain has the exact matching ID.
- *
- * Error handling: if trajectory write fails, continues without pain_event_id.
- * If flag write fails, the error propagates to the caller.
- */
-export function recordAndWritePainFlag(
-  wctx: {
-    trajectory?: { recordPainEvent(input: { sessionId: string; source: string; score: number; reason?: string | null; severity?: string | null; origin?: string | null; confidence?: number | null; text?: string }): number } | null;
-    workspaceDir: string;
-  },
-  trajectoryParams: {
-    sessionId: string;
-    source: string;
-    score: number;
-    reason?: string | null;
-    severity?: string | null;
-    origin?: string | null;
-    confidence?: number | null;
-    text?: string;
-  },
-  painFlagParams: {
-    source: string;
-    score: string;
-    reason: string;
-    session_id?: string;
-    agent_id?: string;
-    is_risky?: boolean;
-    trace_id?: string;
-    trigger_text_preview?: string;
-  }
-): void {
-  const trajectoryPainId = wctx.trajectory?.recordPainEvent({
-    sessionId: trajectoryParams.sessionId,
-    source: trajectoryParams.source,
-    score: trajectoryParams.score,
-    reason: trajectoryParams.reason ?? null,
-    severity: trajectoryParams.severity ?? null,
-    origin: trajectoryParams.origin ?? null,
-    confidence: trajectoryParams.confidence ?? null,
-    text: trajectoryParams.text,
-  });
-
-  const painData = buildPainFlag({
-    ...painFlagParams,
-    pain_event_id:
-      trajectoryPainId !== undefined && trajectoryPainId >= 0 ? String(trajectoryPainId) : undefined,
-  });
-
-  writePainFlag(wctx.workspaceDir, painData);
-}
-
 /**
  * Converts a JSON pain flag object to KV format.
  */
@@ -252,10 +182,10 @@ function convertJsonToKv(json: Record<string, unknown>): Record<string, string>
 }
 
 /**
- * Reads and validates the pain flag file with auto-repair.
+ * Reads and validates the legacy pain flag file.
  *
  * - If file doesn't exist → returns {}
- * - If file is JSON format (wrong) → converts to KV, logs warning, rewrites file
+ * - If file is JSON format → converts to KV in memory only
  * - If file is KV format → validates required fields, logs warning if missing
  * - If file has unknown fields → silently ignores them (forward-compatible)
  */
@@ -270,7 +200,8 @@ export function readPainFlagData(projectDir: string): Record<string, string> {
       return {};
     }
 
-    // Detect JSON format (wrong — should be KV)
+    // Detect JSON format. Legacy compatibility only: parse in memory and do not
+    // rewrite .pain_flag, because Runtime V2 must not create or repair this file.
     if (content.startsWith('{')) {
        
       let json: Record<string, unknown>;
@@ -281,12 +212,8 @@ export function readPainFlagData(projectDir: string): Record<string, string> {
         return {};
       }
 
-      // Auto-repair: convert JSON to KV format
       const kvData = convertJsonToKv(json);
-
-      const repaired = serializeKvLines(kvData);
-      atomicWriteFileSync(painFlagPath, repaired);
-      SystemLogger.log(projectDir, 'PAIN_FLAG_AUTO_REPAIRED', `Auto-repaired pain flag from JSON to KV format (${Object.keys(json).length} fields)`);
+      SystemLogger.log(projectDir, 'PAIN_FLAG_LEGACY_JSON_READ', `Read legacy JSON pain flag in memory (${Object.keys(json).length} fields)`);
       return kvData;
     }
 

package/src/core/path-resolver.ts

@@ -306,7 +306,6 @@ export class PathResolver {
             'THINKING_OS': workspacePath.join(workspace, '.principles', 'THINKING_OS.md'),
             'DECISION_POLICY': workspacePath.join(workspace, '.principles', 'DECISION_POLICY.json'),
             'MODELS_DIR': workspacePath.join(workspace, '.principles', 'models'),
-            'PLAN': workspacePath.join(workspace, 'PLAN.md'),
             'AGENT_SCORECARD': workspacePath.join(state, 'AGENT_SCORECARD.json'),
             'PAIN_FLAG': workspacePath.join(state, '.pain_flag'),
             'EVOLUTION_QUEUE': workspacePath.join(state, 'evolution_queue.json'),

package/src/core/paths.ts

@@ -68,7 +68,6 @@ export const PD_FILES = {
     NOCTURNAL_EXPORTS_DIR: PD_DIRS.NOCTURNAL_EXPORTS,
     IMPL_CODE_DIR: PD_DIRS.IMPL_CODE_DIR,
 
-    PLAN: 'PLAN.md',
     MEMORY_MD: 'MEMORY.md',
     HEARTBEAT: 'HEARTBEAT.md',
 

package/src/core/pd-task-reconciler.ts

@@ -80,8 +80,7 @@ export interface ReconcileOptions {
 }
 
  
-async function readCronStore(logger?: { info?: (_: string) => void; warn?: (_: string) => void }): Promise<CronStoreFile> {
- 
+function readCronStore(logger?: { info?: (_: string) => void; warn?: (_: string) => void }): CronStoreFile {
   if (!fs.existsSync(CRON_STORE_PATH)) {
     logger?.info?.(`[PD:Reconciler] cron/jobs.json not found, starting with empty store`);
     return { version: 1, jobs: [] };
@@ -178,101 +177,7 @@ function buildCronJob(
 }
 
  
-function buildTaskPrompt(task: PDTaskSpec, workspaceDir: string, logger?: { info?: (_: string) => void }): string {
-  // Resolve paths dynamically from workspaceDir instead of hardcoding
-  const stateDir = path.join(workspaceDir, '.state');
-  const empathyKeywordsPath = path.join(stateDir, 'empathy_keywords.json');
-  const eventsJsonlPath = path.join(stateDir, 'logs', 'events.jsonl');
-
-  if (task.id === 'empathy-optimizer') {
-    logger?.info?.(`[PD:Reconciler] Building empathy optimizer prompt`);
-    return `You are the Principles Disciple Empathy Keyword Optimizer.
-
-## TASK
-Analyze the current empathy keyword store and recent user message logs to:
-1. Discover NEW frustration expressions not in the current store
-2. ADJUST weights of existing terms based on actual hit frequency
-3. REMOVE terms that produce too many false positives
-
-## WORKFLOW (execute in order)
-
-### Step 1: Read current keyword store
-Use read_file to load:
-\`${empathyKeywordsPath}\`
-
-Examine the "terms" object. For each term note:
-- weight (0.1-0.9): higher = stronger frustration signal
-- hitCount: how many times it matched
-- falsePositiveRate (0.05-0.5): how often it's a false alarm
-
-### Step 2: Read recent message logs
-Use search_file_content to scan:
-\`${eventsJsonlPath}\`
-
-Look for user messages containing frustration signals:
-- Negation: "不对", "错了", "不行", "重做"
-- Anger: "垃圾", "蠢", "废物", "白做"
-- Disappointment: "不行啊", "还是不对", "没解决"
-- Escalation: "你到底在干什么", "你确定吗", "what are you doing"
-
-### Step 3: Write updated keyword store
-Use write_file to save the updated store back to:
-\`${empathyKeywordsPath}\`
-
-The file format is:
-\`\`\`json
-{
-  "version": 1,
-  "lastUpdated": "ISO timestamp",
-  "lastOptimizedAt": "ISO timestamp",
-  "terms": {
-    "TERM": {
-      "weight": 0.5,
-      "source": "seed|llm_discovered|user_reported",
-      "hitCount": 0,
-      "falsePositiveRate": 0.15
-    }
-  },
-  "stats": {
-    "totalHits": 0,
-    "totalFalsePositives": 0,
-    "optimizationCount": 1
-  }
-}
-\`\`\`
-
-**IMPORTANT**: You MUST use the write_file tool. Do NOT just return JSON in your response.
-
-### Step 4: Report summary
-After writing the file, reply with a brief summary:
-\`\`\`
-Empathy keyword optimization complete:
-- Added: N new terms (list them)
-- Updated: M terms (list changes)
-- Removed: K terms (list them)
-- Total terms in store: X
-\`\`\`
-
-## RULES
-- ADD: If you find frustration expressions in logs NOT in current terms
-  - source = "llm_discovered", discoveredAt = current ISO timestamp
-  - weight: 0.5-0.7 for new terms (start conservative)
-  - falsePositiveRate: 0.2-0.3 (uncertain until validated)
-- UPDATE: Adjust based on evidence
-  - High hitCount + low FPR → increase weight
-  - Low hitCount + high FPR → decrease weight
-  - Keep weight in 0.1-0.9, FPR in 0.05-0.5
-- REMOVE: If hitCount=0 AND falsePositiveRate > 0.3 AND term is clearly generic
-  - Don't remove terms that might be valid but rare
-- PRESERVE: Keep existing hitCount, lastHitAt, discoveredAt for existing terms
-- Bump stats.optimizationCount by 1
-- Set lastOptimizedAt to current ISO timestamp
-
-## EXAMPLES
-- "不对" has hitCount=50 → increase weight from 0.5 to 0.7
-- "呵呵" has hitCount=0, FPR=0.4, generic term → REMOVE
-- User says "烦死了" in logs, not in store → ADD weight=0.6, FPR=0.25`;
-  }
+function buildTaskPrompt(task: PDTaskSpec, _workspaceDir: string, _logger?: { info?: (_: string) => void }): string {
   return task.description;
 }
 
@@ -334,8 +239,10 @@ export async function reconcilePDTasks(
       case 'DISABLE':
         if (action.job) {
           if (!dryRun) {
-            action.job.enabled = false;
-            action.job.updatedAtMs = nowMs;
+            const idx = cronStore.jobs.indexOf(action.job);
+            if (idx >= 0) {
+              cronStore.jobs[idx] = { ...action.job, enabled: false, updatedAtMs: nowMs };
+            }
           }
           logger.warn?.(`[PD:Reconciler] Disabled job: ${action.job.name}`);
         }
@@ -381,9 +288,9 @@ function healthCheck(
 ): PDTaskSpec[] {
   const jobByName = new Map(cronStore.jobs.map((j) => [j.name, j]));
 
-  for (const task of tasks) {
+  return tasks.map((task) => {
     const job = jobByName.get(task.name);
-    if (!job) continue;
+    if (!job) return task;
 
     const errors = job.state.consecutiveErrors ?? 0;
     const lastError = job.state.lastError ?? '';
@@ -402,27 +309,31 @@ function healthCheck(
     }
 
     // Auto-disable only for non-timeout errors after 3 consecutive failures
-    if (errors >= 3 && !isTimeout && !task.meta?.autoDisabled) {
-      if (!task.meta) task.meta = {};
-      task.meta.autoDisabled = true;
-      task.meta.autoDisabledAt = Date.now();
-      task.meta.autoDisabledReason = `consecutiveErrors=${errors}`;
-      logger.warn?.(`[PD:Reconciler] Auto-disabled task '${task.id}' due to ${errors} consecutive errors: ${lastError.substring(0, 80)}`);
-    }
+    const shouldAutoDisable = errors >= 3 && !isTimeout && !task.meta?.autoDisabled;
 
     // Reset consecutiveErrors on non-error runs
     if (errors === 0 && task.meta?.autoDisabled) {
       logger.info?.(`[PD:Reconciler] Task '${task.id}' was previously auto-disabled but has 0 consecutive errors now`);
     }
 
-    if (task.meta) {
-      task.meta.consecutiveFailCount = errors;
-      if (job.state.lastRunAtMs) {
-        task.meta.lastFailedAtMs = job.state.lastRunAtMs;
-      }
+    if (shouldAutoDisable || task.meta || job.state.lastRunAtMs) {
+      return {
+        ...task,
+        meta: {
+          ...task.meta,
+          ...(shouldAutoDisable ? {
+            autoDisabled: true,
+            autoDisabledAt: Date.now(),
+            autoDisabledReason: `consecutiveErrors=${errors}`,
+          } : {}),
+          ...(task.meta ? { consecutiveFailCount: errors } : {}),
+          ...(job.state.lastRunAtMs ? { lastFailedAtMs: job.state.lastRunAtMs } : {}),
+        },
+      };
     }
-  }
-  return tasks;
+
+    return task;
+  });
 }
 
 export async function trigger(