selftune 0.2.23 → 0.2.24

package/cli/selftune/orchestrate/execute.ts

@@ -0,0 +1,295 @@
+import {
+  deriveExpectationsFromSkill,
+  gradeSession,
+  resolveLatestSessionForSkill,
+} from "../grading/grade-session.js";
+import type { readGradingResultsForSkill } from "../grading/results.js";
+import { writeGradingBaseline, writeGradingResultToDb } from "../localdb/direct-write.js";
+import type { watch as watchSkill } from "../monitoring/watch.js";
+import type { EvolveOptions, evolve as evolveSkill } from "../evolution/evolve.js";
+import type { ReplayValidationOptions } from "../evolution/engines/replay-engine.js";
+import { buildRuntimeReplayValidationOptions } from "../evolution/validate-host-replay.js";
+import { findRecentlyDeployedSkills } from "./plan.js";
+import type { OrchestrateOptions, SkillAction } from "../orchestrate.js";
+import type { EvolutionAuditEntry, SessionTelemetryRecord, SkillUsageRecord } from "../types.js";
+import { readExcerpt } from "../utils/transcript.js";
+
+export interface ReplayOptionBuildInput {
+  skillName: string;
+  skillPath: string;
+  agent: string | null;
+}
+
+export function buildReplayValidationOptions(
+  input: ReplayOptionBuildInput,
+): ReplayValidationOptions | undefined {
+  const { skillName, skillPath, agent } = input;
+  if (!agent) return undefined;
+
+  return buildRuntimeReplayValidationOptions({
+    skillName,
+    skillPath,
+    agent,
+    contentTarget: "description",
+  });
+}
+
+export interface RunEvolutionPhaseInput {
+  evolveCandidates: SkillAction[];
+  agent: string | null;
+  options: Pick<OrchestrateOptions, "approvalMode" | "dryRun">;
+  resolveSkillPath: (skillName: string) => string | undefined;
+  readGradingResults: typeof readGradingResultsForSkill;
+  evolve: typeof evolveSkill;
+  buildReplayOptions: typeof buildReplayValidationOptions;
+  evolveDefaults: Pick<
+    EvolveOptions,
+    | "paretoEnabled"
+    | "candidateCount"
+    | "tokenEfficiencyEnabled"
+    | "withBaseline"
+    | "validationModel"
+    | "cheapLoop"
+    | "gateModel"
+    | "adaptiveGate"
+    | "proposalModel"
+  >;
+}
+
+export async function runEvolutionPhase(input: RunEvolutionPhaseInput): Promise<SkillAction[]> {
+  const {
+    evolveCandidates,
+    agent,
+    options,
+    resolveSkillPath,
+    readGradingResults,
+    evolve,
+    buildReplayOptions,
+    evolveDefaults,
+  } = input;
+
+  if (!agent) return [];
+
+  for (const candidate of evolveCandidates) {
+    if (candidate.action === "skip") continue;
+
+    const skillPath = resolveSkillPath(candidate.skill);
+    if (!skillPath) {
+      candidate.action = "skip";
+      candidate.reason = `SKILL.md not found for "${candidate.skill}"`;
+      console.error(`  ⊘ ${candidate.skill}: ${candidate.reason}`);
+      continue;
+    }
+
+    const effectiveDryRun = options.dryRun || options.approvalMode === "review";
+    console.error(
+      `[orchestrate] Evolving "${candidate.skill}"${effectiveDryRun ? " (dry-run)" : ""}...`,
+    );
+
+    try {
+      const evolveResult = await evolve({
+        skillName: candidate.skill,
+        skillPath,
+        agent,
+        dryRun: effectiveDryRun,
+        confidenceThreshold: 0.6,
+        maxIterations: 3,
+        gradingResults: readGradingResults(candidate.skill),
+        syncFirst: false,
+        replayOptions: buildReplayOptions({
+          skillName: candidate.skill,
+          skillPath,
+          agent,
+        }),
+        ...evolveDefaults,
+      });
+
+      candidate.evolveResult = evolveResult;
+
+      if (evolveResult.deployed) {
+        console.error(`  ✓ ${candidate.skill}: deployed (${evolveResult.reason})`);
+      } else {
+        console.error(`  ✗ ${candidate.skill}: not deployed (${evolveResult.reason})`);
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      candidate.action = "skip";
+      candidate.reason = `evolve error: ${msg}`;
+      console.error(`  ✗ ${candidate.skill}: error — ${msg}`);
+    }
+  }
+
+  return evolveCandidates.filter(
+    (candidate) => candidate.action === "evolve" && candidate.evolveResult?.deployed,
+  );
+}
+
+export interface AutoGradeFreshDeploysInput {
+  freshlyDeployedCandidates: SkillAction[];
+  dryRun: boolean;
+  agent: string | null;
+  detectAgent: () => string | null;
+  readTelemetry: () => SessionTelemetryRecord[];
+  readSkillRecords: () => SkillUsageRecord[];
+}
+
+export async function autoGradeFreshDeploys(input: AutoGradeFreshDeploysInput): Promise<void> {
+  const { freshlyDeployedCandidates, dryRun, agent, detectAgent, readTelemetry, readSkillRecords } =
+    input;
+
+  if (dryRun || freshlyDeployedCandidates.length === 0) return;
+
+  const gradeAgent = agent ?? detectAgent();
+  if (!gradeAgent) return;
+
+  for (const candidate of freshlyDeployedCandidates) {
+    try {
+      const freshTelemetry = readTelemetry();
+      const freshSkillUsage = readSkillRecords();
+      let gradedCount = 0;
+      const gradingPassRates: number[] = [];
+
+      const resolved = resolveLatestSessionForSkill(
+        freshTelemetry,
+        freshSkillUsage,
+        candidate.skill,
+      );
+      if (resolved) {
+        const derived = deriveExpectationsFromSkill(candidate.skill);
+        let transcriptExcerpt = "(no transcript)";
+        if (resolved.transcriptPath) {
+          try {
+            transcriptExcerpt = readExcerpt(resolved.transcriptPath);
+          } catch {
+            transcriptExcerpt = "(no transcript)";
+          }
+        }
+
+        const result = await gradeSession({
+          expectations: derived.expectations,
+          telemetry: resolved.telemetry,
+          sessionId: resolved.sessionId,
+          skillName: candidate.skill,
+          transcriptExcerpt,
+          transcriptPath: resolved.transcriptPath,
+          agent: gradeAgent,
+        });
+
+        const persisted = writeGradingResultToDb(result);
+        if (persisted) {
+          gradedCount++;
+          gradingPassRates.push(result.summary.pass_rate);
+        }
+      }
+
+      if (gradedCount > 0) {
+        const avgPassRate =
+          gradingPassRates.reduce((sum, passRate) => sum + passRate, 0) / gradingPassRates.length;
+        const proposalId = candidate.evolveResult?.auditEntries?.find(
+          (entry: { action: string }) => entry.action === "deployed",
+        )?.proposal_id;
+
+        writeGradingBaseline({
+          skill_name: candidate.skill,
+          proposal_id: proposalId ?? null,
+          measured_at: new Date().toISOString(),
+          pass_rate: avgPassRate,
+          mean_score: null,
+          sample_size: gradedCount,
+          grading_results_json: JSON.stringify(gradingPassRates),
+        });
+
+        console.error(
+          `  [post-deploy] ${candidate.skill}: graded ${gradedCount} session(s), baseline pass_rate=${avgPassRate.toFixed(2)}`,
+        );
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`  [post-deploy] ${candidate.skill}: auto-grade error — ${msg}`);
+    }
+  }
+}
+
+export interface WatchRecentDeploysInput {
+  candidates: SkillAction[];
+  freshlyDeployedCandidates: SkillAction[];
+  skillFilter?: string;
+  recentWindowHours: number;
+  readAuditEntries: () => EvolutionAuditEntry[];
+  resolveSkillPath: (skillName: string) => string | undefined;
+  watch: typeof watchSkill;
+}
+
+export async function watchRecentDeploys(
+  input: WatchRecentDeploysInput,
+): Promise<{ freshAuditEntries: EvolutionAuditEntry[]; freshlyWatchedSkills: string[] }> {
+  const {
+    candidates,
+    freshlyDeployedCandidates,
+    skillFilter,
+    recentWindowHours,
+    readAuditEntries,
+    resolveSkillPath,
+    watch,
+  } = input;
+
+  const freshAuditEntries = readAuditEntries();
+  const recentlyEvolved = findRecentlyDeployedSkills(freshAuditEntries, recentWindowHours);
+
+  for (const candidate of freshlyDeployedCandidates) {
+    recentlyEvolved.add(candidate.skill);
+  }
+
+  const freshlyWatchedSkills: string[] = [];
+
+  for (const skillName of recentlyEvolved) {
+    if (skillFilter && skillName !== skillFilter) continue;
+
+    const skillPath = resolveSkillPath(skillName);
+    if (!skillPath) continue;
+
+    const isFreshlyDeployed = freshlyDeployedCandidates.some(
+      (candidate) => candidate.skill === skillName,
+    );
+    const label = isFreshlyDeployed ? "freshly deployed" : "recently evolved";
+    console.error(`[orchestrate] Watching "${skillName}" (${label})...`);
+
+    try {
+      const watchResult = await watch({
+        skillName,
+        skillPath,
+        windowSessions: 20,
+        regressionThreshold: 0.1,
+        autoRollback: true,
+        enableGradeWatch: true,
+        syncFirst: false,
+      });
+
+      if (isFreshlyDeployed) {
+        const existingCandidate = candidates.find(
+          (candidate) => candidate.skill === skillName && candidate.action === "evolve",
+        );
+        if (existingCandidate) {
+          existingCandidate.watchResult = watchResult;
+        }
+        freshlyWatchedSkills.push(skillName);
+      } else {
+        candidates.push({
+          skill: skillName,
+          action: "watch",
+          reason: watchResult.alert ?? "stable",
+          watchResult,
+        });
+      }
+
+      console.error(
+        `  ${watchResult.alert ? "⚠" : "✓"} ${skillName}: ${watchResult.recommendation}`,
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`  ✗ ${skillName}: watch error — ${msg}`);
+    }
+  }
+
+  return { freshAuditEntries, freshlyWatchedSkills };
+}

package/cli/selftune/orchestrate/finalize.ts

@@ -0,0 +1,157 @@
+import type { OrchestrateRunReport, OrchestrateRunSkillAction } from "../dashboard-contract.js";
+import { getDb } from "../localdb/db.js";
+import { writeCronRunToDb, writeOrchestrateRunToDb } from "../localdb/direct-write.js";
+import type { OrchestrateResult, SkillAction } from "../orchestrate.js";
+import type { SkillStatus, StatusResult } from "../status.js";
+import type { SyncResult } from "../sync.js";
+import type { ImprovementSignalRecord } from "../types.js";
+import type { WorkflowSkillProposal } from "../workflows/proposals.js";
+import { markSignalsConsumed } from "./signals.js";
+
+interface OrchestrateFinalTotals {
+  totalSkills: number;
+  evaluated: number;
+  evolved: number;
+  deployed: number;
+  watched: number;
+  skipped: number;
+  autoGraded: number;
+  freshlyWatchedSkills: string[];
+}
+
+export interface FinalizeOrchestrateRunInput {
+  syncResult: SyncResult;
+  statusResult: StatusResult;
+  candidates: SkillAction[];
+  workflowProposals: WorkflowSkillProposal[];
+  dryRun: boolean;
+  approvalMode: "auto" | "review";
+  autoGradedCount: number;
+  freshlyWatchedSkills: string[];
+  pendingSignals: ImprovementSignalRecord[];
+  elapsedMs: number;
+}
+
+function buildFinalTotals(
+  skills: SkillStatus[],
+  candidates: SkillAction[],
+  autoGradedCount: number,
+  freshlyWatchedSkills: string[],
+): OrchestrateFinalTotals {
+  return {
+    totalSkills: skills.length,
+    evaluated: candidates.filter((candidate) => candidate.action === "evolve").length,
+    evolved: candidates.filter(
+      (candidate) => candidate.action === "evolve" && candidate.evolveResult !== undefined,
+    ).length,
+    deployed: candidates.filter((candidate) => candidate.evolveResult?.deployed).length,
+    watched:
+      candidates.filter((candidate) => candidate.action === "watch").length +
+      freshlyWatchedSkills.length,
+    skipped: candidates.filter((candidate) => candidate.action === "skip").length,
+    autoGraded: autoGradedCount,
+    freshlyWatchedSkills,
+  };
+}
+
+export function finalizeOrchestrateRun(input: FinalizeOrchestrateRunInput): OrchestrateResult {
+  const {
+    syncResult,
+    statusResult,
+    candidates,
+    workflowProposals,
+    dryRun,
+    approvalMode,
+    autoGradedCount,
+    freshlyWatchedSkills,
+    pendingSignals,
+    elapsedMs,
+  } = input;
+
+  const finalTotals = buildFinalTotals(
+    statusResult.skills,
+    candidates,
+    autoGradedCount,
+    freshlyWatchedSkills,
+  );
+
+  const result: OrchestrateResult = {
+    syncResult,
+    statusResult,
+    candidates,
+    workflowProposals,
+    summary: {
+      ...finalTotals,
+      dryRun,
+      approvalMode,
+      elapsedMs,
+    },
+  };
+
+  const runId = `run_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  if (pendingSignals.length > 0) {
+    markSignalsConsumed(pendingSignals, runId);
+  }
+
+  const runReport: OrchestrateRunReport = {
+    run_id: runId,
+    timestamp: new Date().toISOString(),
+    elapsed_ms: result.summary.elapsedMs,
+    dry_run: result.summary.dryRun,
+    approval_mode: result.summary.approvalMode,
+    total_skills: finalTotals.totalSkills,
+    evaluated: finalTotals.evaluated,
+    evolved: finalTotals.evolved,
+    deployed: finalTotals.deployed,
+    watched: finalTotals.watched,
+    skipped: finalTotals.skipped,
+    auto_graded: finalTotals.autoGraded,
+    skill_actions: candidates.map(
+      (candidate): OrchestrateRunSkillAction => ({
+        skill: candidate.skill,
+        action: candidate.action,
+        reason: candidate.reason,
+        deployed: candidate.evolveResult?.deployed,
+        rolledBack: candidate.watchResult?.rolledBack,
+        alert: candidate.watchResult?.alert,
+        elapsed_ms: candidate.evolveResult?.elapsedMs,
+        llm_calls: candidate.evolveResult?.llmCallCount,
+      }),
+    ),
+  };
+
+  try {
+    writeOrchestrateRunToDb(runReport);
+  } catch {
+    /* fail-open */
+  }
+
+  const totalLlmCalls = candidates.reduce(
+    (sum, candidate) => sum + (candidate.evolveResult?.llmCallCount ?? 0),
+    0,
+  );
+  try {
+    writeCronRunToDb(getDb(), {
+      jobName: "orchestrate",
+      startedAt: runReport.timestamp,
+      elapsedMs: runReport.elapsed_ms,
+      status: "success",
+      metrics: {
+        total_skills: finalTotals.totalSkills,
+        evaluated: finalTotals.evaluated,
+        evolved: finalTotals.evolved,
+        deployed: finalTotals.deployed,
+        watched: finalTotals.watched,
+        skipped: finalTotals.skipped,
+        dry_run: result.summary.dryRun,
+        total_llm_calls: totalLlmCalls,
+        auto_graded: finalTotals.autoGraded,
+        workflow_skill_proposals: workflowProposals.length,
+      },
+    });
+  } catch {
+    /* fail-open */
+  }
+
+  return result;
+}

package/cli/selftune/orchestrate/locks.ts

@@ -0,0 +1,40 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+
+import { getOrchestrateLockPath } from "../constants.js";
+
+interface LockInfo {
+  pid: number;
+  timestamp: string;
+}
+
+const LOCK_STALE_MS = 30 * 60 * 1000; // 30 minutes
+
+export function acquireLock(lockPath: string = getOrchestrateLockPath()): boolean {
+  try {
+    if (existsSync(lockPath)) {
+      try {
+        const raw = readFileSync(lockPath, "utf-8");
+        const info: LockInfo = JSON.parse(raw);
+        const lockAge = Date.now() - Date.parse(info.timestamp);
+        if (lockAge < LOCK_STALE_MS) {
+          return false;
+        }
+      } catch {
+        // Corrupted lock file, treat as stale and overwrite.
+      }
+    }
+    const lock: LockInfo = { pid: process.pid, timestamp: new Date().toISOString() };
+    writeFileSync(lockPath, JSON.stringify(lock));
+    return true;
+  } catch {
+    return true;
+  }
+}
+
+export function releaseLock(lockPath: string = getOrchestrateLockPath()): void {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+    // Silent on errors (file may not exist).
+  }
+}

package/cli/selftune/orchestrate/plan.ts

@@ -0,0 +1,131 @@
+import type { CandidateContext, SkillAction } from "../orchestrate.js";
+import type { SkillStatus } from "../status.js";
+import type { EvolutionAuditEntry } from "../types.js";
+
+/** Candidate selection criteria. */
+const CANDIDATE_STATUSES = new Set(["CRITICAL", "WARNING", "UNGRADED"]);
+
+/** Minimum skill_checks before autonomous evolution is allowed. */
+export const MIN_CANDIDATE_EVIDENCE = 3;
+
+/** Default cooldown hours after a deploy before re-evolving the same skill. */
+export const DEFAULT_COOLDOWN_HOURS = 24;
+
+function candidatePriority(skill: SkillStatus, signalCount = 0): number {
+  const statusWeight = skill.status === "CRITICAL" ? 300 : skill.status === "WARNING" ? 200 : 100;
+  const missedWeight = Math.min(skill.missedQueries, 50);
+  const passPenalty = skill.passRate === null ? 0 : Math.round((1 - skill.passRate) * 100);
+  const trendBoost = skill.trend === "down" ? 30 : 0;
+  const signalBoost = Math.min(signalCount * 150, 450);
+  return statusWeight + missedWeight + passPenalty + trendBoost + signalBoost;
+}
+
+export function findRecentlyDeployedSkills(
+  auditEntries: EvolutionAuditEntry[],
+  windowHours: number,
+): Set<string> {
+  const cutoffMs = Date.now() - windowHours * 60 * 60 * 1000;
+  const names = new Set<string>();
+  for (const entry of auditEntries) {
+    const deployedAtMs = Date.parse(entry.timestamp);
+    if (
+      entry.action === "deployed" &&
+      entry.skill_name &&
+      Number.isFinite(deployedAtMs) &&
+      deployedAtMs >= cutoffMs
+    ) {
+      names.add(entry.skill_name);
+    }
+  }
+  return names;
+}
+
+export function selectCandidates(skills: SkillStatus[], options: CandidateContext): SkillAction[] {
+  const actions: SkillAction[] = [];
+  const orderedSkills = [...skills].sort((a, b) => {
+    const aSignals = options.signaledSkills?.get(a.name.toLowerCase()) ?? 0;
+    const bSignals = options.signaledSkills?.get(b.name.toLowerCase()) ?? 0;
+    return candidatePriority(b, bSignals) - candidatePriority(a, aSignals);
+  });
+
+  const cooldownHours = options.cooldownHours ?? DEFAULT_COOLDOWN_HOURS;
+  const recentlyDeployed = findRecentlyDeployedSkills(options.auditEntries ?? [], cooldownHours);
+
+  for (const skill of orderedSkills) {
+    const signalCount = options.signaledSkills?.get(skill.name.toLowerCase()) ?? 0;
+
+    if (options.skillFilter && skill.name !== options.skillFilter) {
+      actions.push({
+        skill: skill.name,
+        action: "skip",
+        reason: `filtered out (--skill ${options.skillFilter})`,
+      });
+      continue;
+    }
+
+    if (!CANDIDATE_STATUSES.has(skill.status)) {
+      actions.push({
+        skill: skill.name,
+        action: "skip",
+        reason: `status=${skill.status} — no action needed`,
+      });
+      continue;
+    }
+
+    if (recentlyDeployed.has(skill.name)) {
+      actions.push({
+        skill: skill.name,
+        action: "skip",
+        reason: `recently evolved (cooldown ${cooldownHours}h) — let it bake`,
+      });
+      continue;
+    }
+
+    const skillChecks = skill.snapshot?.skill_checks ?? 0;
+    if (skillChecks < MIN_CANDIDATE_EVIDENCE && skill.status !== "UNGRADED" && signalCount === 0) {
+      actions.push({
+        skill: skill.name,
+        action: "skip",
+        reason: `insufficient evidence (${skillChecks}/${MIN_CANDIDATE_EVIDENCE} checks) — need more data`,
+      });
+      continue;
+    }
+
+    if (skill.status === "UNGRADED" && skill.missedQueries === 0 && signalCount === 0) {
+      actions.push({
+        skill: skill.name,
+        action: "skip",
+        reason: "UNGRADED with 0 missed queries — insufficient signal",
+      });
+      continue;
+    }
+
+    if (skill.status === "WARNING" && skill.missedQueries === 0 && skill.trend !== "down") {
+      actions.push({
+        skill: skill.name,
+        action: "skip",
+        reason: `WARNING but no missed queries and trend=${skill.trend} — weak signal`,
+      });
+      continue;
+    }
+
+    actions.push({
+      skill: skill.name,
+      action: "evolve",
+      reason: `status=${skill.status}, passRate=${skill.passRate !== null ? `${(skill.passRate * 100).toFixed(0)}%` : "—"}, missed=${skill.missedQueries}, trend=${skill.trend}`,
+    });
+  }
+
+  let evolveCount = 0;
+  for (const action of actions) {
+    if (action.action === "evolve") {
+      evolveCount++;
+      if (evolveCount > options.maxSkills) {
+        action.action = "skip";
+        action.reason = `capped by --max-skills ${options.maxSkills}`;
+      }
+    }
+  }
+
+  return actions;
+}

package/cli/selftune/orchestrate/post-run.ts

@@ -0,0 +1,59 @@
+import { readConfiguredAgentType, getSelftuneVersion } from "../utils/selftune-meta.js";
+import { getDb } from "../localdb/db.js";
+import type { OrchestrateResult } from "../orchestrate.js";
+import { SELFTUNE_CONFIG_PATH } from "../constants.js";
+import type { AlphaIdentity } from "../types.js";
+
+export async function runPostOrchestrateSideEffects(input: {
+  result: OrchestrateResult;
+  dryRun: boolean;
+  readAlphaIdentity: () => AlphaIdentity | null;
+}): Promise<void> {
+  const { result, dryRun, readAlphaIdentity } = input;
+  const alphaIdentity = readAlphaIdentity();
+
+  if (alphaIdentity?.enrolled) {
+    try {
+      console.error("[orchestrate] Running alpha upload cycle...");
+      const { runUploadCycle } = await import("../alpha-upload/index.js");
+      const uploadSummary = await runUploadCycle(getDb(), {
+        enrolled: true,
+        userId: alphaIdentity.user_id,
+        agentType: readConfiguredAgentType(SELFTUNE_CONFIG_PATH, "unknown"),
+        selftuneVersion: getSelftuneVersion(),
+        dryRun,
+        apiKey: alphaIdentity.api_key,
+      });
+      result.uploadSummary = uploadSummary;
+      console.error(
+        `[orchestrate] Alpha upload: prepared=${uploadSummary.prepared}, sent=${uploadSummary.sent}, failed=${uploadSummary.failed}, skipped=${uploadSummary.skipped}`,
+      );
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[orchestrate] Alpha upload failed (non-blocking): ${msg}`);
+    }
+  }
+
+  if (alphaIdentity?.api_key) {
+    try {
+      const { flushCreatorContributionSignals } = await import("../contribution-relay.js");
+      const relayResult = await flushCreatorContributionSignals(getDb(), {
+        apiKey: alphaIdentity.api_key,
+        dryRun,
+      });
+      if (relayResult.attempted > 0) {
+        result.contributionRelaySummary = {
+          attempted: relayResult.attempted,
+          sent: relayResult.sent,
+          failed: relayResult.failed,
+        };
+        console.error(
+          `[orchestrate] Contribution relay: attempted=${relayResult.attempted}, sent=${relayResult.sent}, failed=${relayResult.failed}`,
+        );
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.error(`[orchestrate] Contribution relay failed (non-blocking): ${msg}`);
+    }
+  }
+}