selftune 0.2.6 → 0.2.8

package/cli/selftune/evolution/evolve.ts

@@ -9,11 +9,17 @@
 import { copyFileSync, existsSync, readFileSync, writeFileSync } from "node:fs";
 import { parseArgs } from "node:util";
 
-import { QUERY_LOG, SKILL_LOG, TELEMETRY_LOG } from "../constants.js";
+import { QUERY_LOG, SKILL_LOG } from "../constants.js";
 import type { BaselineMeasurement } from "../eval/baseline.js";
 import { measureBaseline } from "../eval/baseline.js";
 import { buildEvalSet } from "../eval/hooks-to-evals.js";
 import { readGradingResultsForSkill } from "../grading/results.js";
+import { getDb } from "../localdb/db.js";
+import {
+  queryQueryLog,
+  querySessionTelemetry,
+  querySkillUsageRecords,
+} from "../localdb/queries.js";
 import { updateContextAfterEvolve } from "../memory/writer.js";
 import type { SyncResult } from "../sync.js";
 import type {
@@ -31,10 +37,10 @@ import type {
   SkillUsageRecord,
 } from "../types.js";
 import { parseFrontmatter, replaceFrontmatterDescription } from "../utils/frontmatter.js";
-import { readJsonl } from "../utils/jsonl.js";
-import { readEffectiveSkillUsageRecords } from "../utils/skill-log.js";
+
 import { createEvolveTUI } from "../utils/tui.js";
 import { appendAuditEntry } from "./audit.js";
+import { checkConstitution } from "./constitutional.js";
 import { appendEvidenceEntry } from "./evidence.js";
 import { extractFailurePatterns } from "./extract-patterns.js";
 import {
@@ -124,6 +130,7 @@ function createAuditEntry(
   details: string,
   evalSnapshot?: EvalPassRate,
   skillName?: string,
+  iterationsUsed?: number,
 ): EvolutionAuditEntry {
   return {
     timestamp: new Date().toISOString(),
@@ -132,6 +139,7 @@ function createAuditEntry(
     details,
     ...(skillName ? { skill_name: skillName } : {}),
     ...(evalSnapshot ? { eval_snapshot: evalSnapshot } : {}),
+    ...(iterationsUsed != null ? { iterations_used: iterationsUsed } : {}),
   };
 }
 
@@ -190,7 +198,12 @@ export async function evolve(
   const _buildEvalSet = _deps.buildEvalSet ?? buildEvalSet;
   const _updateContextAfterEvolve = _deps.updateContextAfterEvolve ?? updateContextAfterEvolve;
   const _measureBaseline = _deps.measureBaseline ?? measureBaseline;
-  const _readSkillUsageLog = _deps.readSkillUsageLog ?? (() => readEffectiveSkillUsageRecords());
+  const _readSkillUsageLog =
+    _deps.readSkillUsageLog ??
+    (() => {
+      const db = getDb();
+      return querySkillUsageRecords(db) as SkillUsageRecord[];
+    });
 
   const auditEntries: EvolutionAuditEntry[] = [];
   let syncResult: SyncResult | undefined;
@@ -200,8 +213,16 @@ export async function evolve(
     action: EvolutionAuditEntry["action"],
     details: string,
     evalSnapshot?: EvalPassRate,
+    iterationsUsed?: number,
   ): void {
-    const entry = createAuditEntry(proposalId, action, details, evalSnapshot, skillName);
+    const entry = createAuditEntry(
+      proposalId,
+      action,
+      details,
+      evalSnapshot,
+      skillName,
+      iterationsUsed,
+    );
     auditEntries.push(entry);
     try {
       _appendAuditEntry(entry);
@@ -316,7 +337,8 @@ export async function evolve(
       }
     } else {
       // Build from logs
-      const queryRecords = readJsonl<QueryLogRecord>(QUERY_LOG);
+      const dbForQuery = getDb();
+      const queryRecords = queryQueryLog(dbForQuery) as QueryLogRecord[];
       evalSet = _buildEvalSet(skillUsage, queryRecords, skillName);
     }
 
@@ -342,6 +364,33 @@ export async function evolve(
       `Extracted ${failurePatterns.length} failure pattern(s) (${totalMissed} missed queries)`,
     );
 
+    // Compute aggregate grading metrics for proposal context
+    const aggregateMetrics = options.gradingResults?.length
+      ? (() => {
+          const scores = options.gradingResults.map(
+            (r) => r.summary.mean_score ?? r.summary.pass_rate,
+          );
+          const meanScore = scores.reduce((a, b) => a + b, 0) / scores.length;
+          const scoreStdDev = Math.sqrt(
+            scores.reduce((sum, s) => sum + (s - meanScore) ** 2, 0) / scores.length,
+          );
+          const failedRate =
+            options.gradingResults.filter((r) => r.summary.failed > 0).length /
+            options.gradingResults.length;
+          const errors = options.gradingResults.map(
+            (r) => r.execution_metrics?.errors_encountered ?? 0,
+          );
+          const meanErrors = errors.reduce((a, b) => a + b, 0) / errors.length;
+          return {
+            mean_score: meanScore,
+            score_std_dev: scoreStdDev,
+            failed_session_rate: failedRate,
+            mean_errors: meanErrors,
+            total_graded: options.gradingResults.length,
+          };
+        })()
+      : undefined;
+
     // -----------------------------------------------------------------------
     // Step 5: Cold-start bootstrap or early exit if no patterns
     // -----------------------------------------------------------------------
@@ -394,7 +443,12 @@ export async function evolve(
     const tokenEfficiencyEnabled = options.tokenEfficiencyEnabled ?? false;
     const telemetryRecords =
       options.telemetryRecords ??
-      (tokenEfficiencyEnabled ? readJsonl<SessionTelemetryRecord>(TELEMETRY_LOG) : undefined);
+      (tokenEfficiencyEnabled
+        ? (() => {
+            const dbTel = getDb();
+            return querySessionTelemetry(dbTel) as SessionTelemetryRecord[];
+          })()
+        : undefined);
 
     // Compute token efficiency score if enabled and telemetry is available
     let tokenEffScore: number | undefined;
@@ -407,6 +461,8 @@ export async function evolve(
       );
     }
 
+    let iterationsCompleted = 0;
+
     if (paretoEnabled && candidateCount > 1) {
       // Generate N candidates in parallel
       const candidates = await generateMultipleProposals(
@@ -418,6 +474,7 @@ export async function evolve(
         agent,
         candidateCount,
         options.proposalModel,
+        aggregateMetrics,
       );
 
       // Filter by confidence threshold
@@ -457,6 +514,32 @@ export async function evolve(
           eval_set: evalSet,
         });
 
+        // Constitutional check before validation (same gate as retry flow)
+        const constitution = checkConstitution(
+          proposal.proposed_description,
+          currentDescription,
+          skillName,
+        );
+        if (!constitution.passed) {
+          const reason = `Constitutional: ${constitution.violations.join("; ")}`;
+          recordAudit(proposal.proposal_id, "rejected", reason);
+          recordEvidence({
+            timestamp: new Date().toISOString(),
+            proposal_id: proposal.proposal_id,
+            skill_name: skillName,
+            skill_path: skillPath,
+            target: "description",
+            stage: "rejected",
+            rationale: proposal.rationale,
+            confidence: proposal.confidence,
+            details: reason,
+            original_text: proposal.original_description,
+            proposed_text: proposal.proposed_description,
+            eval_set: evalSet,
+          });
+          continue;
+        }
+
         const validation = await _validateProposal(
           proposal,
           evalSet,
@@ -521,6 +604,7 @@ export async function evolve(
 
       lastProposal = best.proposal;
       lastValidation = best.validation;
+      iterationsCompleted = 1; // Pareto selection is a single-pass
 
       // Skip the standard retry loop — we already have our result
     } else {
@@ -528,6 +612,7 @@ export async function evolve(
       let feedbackReason = "";
 
       for (let iteration = 0; iteration < maxIterations; iteration++) {
+        iterationsCompleted = iteration + 1;
         // Step 7: Generate proposal
         const effectiveMissedQueries = feedbackReason
           ? [...missedQueries, `[Previous attempt failed: ${feedbackReason}]`]
@@ -542,6 +627,7 @@ export async function evolve(
           skillPath,
           agent,
           options.proposalModel,
+          aggregateMetrics,
         );
         llmCallCount++;
 
@@ -569,6 +655,39 @@ export async function evolve(
           eval_set: evalSet,
         });
 
+        // Step 8b: Constitutional check (deterministic, pre-validation)
+        const constitution = checkConstitution(
+          proposal.proposed_description,
+          currentDescription,
+          skillName,
+        );
+        if (!constitution.passed) {
+          feedbackReason = `Constitutional: ${constitution.violations.join("; ")}`;
+          recordAudit(proposal.proposal_id, "rejected", feedbackReason);
+          recordEvidence({
+            timestamp: new Date().toISOString(),
+            proposal_id: proposal.proposal_id,
+            skill_name: skillName,
+            skill_path: skillPath,
+            target: "description",
+            stage: "rejected",
+            rationale: proposal.rationale,
+            confidence: proposal.confidence,
+            details: feedbackReason,
+          });
+          if (iteration === maxIterations - 1) {
+            finishTui();
+            return withStats({
+              proposal: lastProposal,
+              validation: null,
+              deployed: false,
+              auditEntries,
+              reason: feedbackReason,
+            });
+          }
+          continue;
+        }
+
         // Step 9: Check confidence threshold
         if (proposal.confidence < confidenceThreshold) {
           feedbackReason = `Confidence ${proposal.confidence} below threshold ${confidenceThreshold}`;
@@ -742,6 +861,26 @@ export async function evolve(
       );
 
       if (!baselineResult.adds_value) {
+        recordAudit(
+          lastProposal.proposal_id,
+          "rejected",
+          `Baseline gate failed: lift=${baselineResult.lift.toFixed(3)} below 0.05 threshold`,
+        );
+        recordEvidence({
+          timestamp: new Date().toISOString(),
+          proposal_id: lastProposal.proposal_id,
+          skill_name: skillName,
+          skill_path: skillPath,
+          target: "description",
+          stage: "rejected",
+          rationale: lastProposal.rationale,
+          confidence: lastProposal.confidence,
+          details: `Baseline gate failed: lift=${baselineResult.lift.toFixed(3)} below 0.05 threshold`,
+          validation: {
+            improved: false,
+            net_change: baselineResult.lift,
+          },
+        });
         finishTui();
         return withStats({
           proposal: lastProposal,
@@ -761,17 +900,37 @@ export async function evolve(
     if (options.gateModel && lastProposal && lastValidation?.improved) {
       tui.step(`Gate validation (${options.gateModel})...`);
       gateValidation = await _gateValidateProposal(lastProposal, evalSet, agent, options.gateModel);
+      llmCallCount++;
       tui.done(
         `Gate (${options.gateModel}): improved=${gateValidation.improved}, net_change=${gateValidation.net_change.toFixed(3)}`,
       );
 
-      recordAudit(
-        lastProposal.proposal_id,
-        "validated",
-        `Gate validation (${options.gateModel}): improved=${gateValidation.improved}, net_change=${gateValidation.net_change.toFixed(3)}`,
-      );
-
       if (!gateValidation.improved) {
+        recordAudit(
+          lastProposal.proposal_id,
+          "rejected",
+          `Gate validation failed (${options.gateModel}): net_change=${gateValidation.net_change.toFixed(3)}`,
+        );
+        recordEvidence({
+          timestamp: new Date().toISOString(),
+          proposal_id: lastProposal.proposal_id,
+          skill_name: skillName,
+          skill_path: skillPath,
+          target: "description",
+          stage: "rejected",
+          rationale: lastProposal.rationale,
+          confidence: lastProposal.confidence,
+          details: `Gate validation failed (${options.gateModel}): net_change=${gateValidation.net_change.toFixed(3)}`,
+          validation: {
+            improved: gateValidation.improved,
+            before_pass_rate: gateValidation.before_pass_rate,
+            after_pass_rate: gateValidation.after_pass_rate,
+            net_change: gateValidation.net_change,
+            regressions: gateValidation.regressions,
+            new_passes: gateValidation.new_passes,
+            per_entry_results: gateValidation.per_entry_results,
+          },
+        });
         finishTui();
         return withStats({
           proposal: lastProposal,
@@ -783,6 +942,12 @@ export async function evolve(
           ...(baselineResult ? { baselineResult } : {}),
         });
       }
+
+      recordAudit(
+        lastProposal.proposal_id,
+        "validated",
+        `Gate validation (${options.gateModel}): improved=${gateValidation.improved}, net_change=${gateValidation.net_change.toFixed(3)}`,
+      );
     }
 
     // -----------------------------------------------------------------------
@@ -810,12 +975,18 @@ export async function evolve(
         console.error("------------------------------\n");
       }
 
-      recordAudit(lastProposal.proposal_id, "deployed", `Deployed proposal for ${skillName}`, {
-        total: evalSet.length,
-        passed: Math.round(lastValidation.after_pass_rate * evalSet.length),
-        failed: evalSet.length - Math.round(lastValidation.after_pass_rate * evalSet.length),
-        pass_rate: lastValidation.after_pass_rate,
-      });
+      recordAudit(
+        lastProposal.proposal_id,
+        "deployed",
+        `Deployed proposal for ${skillName}`,
+        {
+          total: evalSet.length,
+          passed: Math.round(lastValidation.after_pass_rate * evalSet.length),
+          failed: evalSet.length - Math.round(lastValidation.after_pass_rate * evalSet.length),
+          pass_rate: lastValidation.after_pass_rate,
+        },
+        iterationsCompleted,
+      );
       recordEvidence({
         timestamp: new Date().toISOString(),
         proposal_id: lastProposal.proposal_id,
@@ -1001,7 +1172,8 @@ Options:
 
   // If no eval-set provided, check that log files exist for auto-generation
   if (!evalSetPath && !(values["sync-first"] ?? false)) {
-    const hasSkillLog = readEffectiveSkillUsageRecords().length > 0;
+    const dbCheck = getDb();
+    const hasSkillLog = querySkillUsageRecords(dbCheck).length > 0;
     const hasQueryLog = existsSync(QUERY_LOG);
     if (!hasSkillLog && !hasQueryLog) {
       console.error("[ERROR] No eval set provided and no telemetry logs found.");
@@ -1016,7 +1188,8 @@ Options:
   const tokenEfficiencyEnabled = values["token-efficiency"] ?? false;
   let telemetryRecords: SessionTelemetryRecord[] | undefined;
   if (tokenEfficiencyEnabled && !(values["sync-first"] ?? false)) {
-    telemetryRecords = readJsonl<SessionTelemetryRecord>(TELEMETRY_LOG);
+    const dbTel2 = getDb();
+    telemetryRecords = querySessionTelemetry(dbTel2) as SessionTelemetryRecord[];
   }
   const gradingResults = readGradingResultsForSkill(values.skill);
 
@@ -1117,7 +1290,7 @@ if (import.meta.main) {
     console.error(
       "\nTroubleshooting:\n" +
         "  - Verify --skill-path points to a valid SKILL.md file\n" +
-        "  - Ensure eval data exists (run `selftune evals` first) or pass --eval-set\n" +
+        "  - Ensure eval data exists (run `selftune eval generate` first) or pass --eval-set\n" +
         "  - Check that ANTHROPIC_API_KEY is set if using Claude\n" +
         "  - Re-run with --verbose for full diagnostic output",
     );

package/cli/selftune/evolution/propose-body.ts

@@ -37,6 +37,15 @@ Do NOT include any text outside the JSON object.`;
 // Prompt builder
 // ---------------------------------------------------------------------------
 
+/** Execution telemetry context for body evolution proposals. */
+export interface ExecutionContext {
+  avgToolCalls: number;
+  avgErrors: number;
+  avgTurns: number;
+  commonTools: string[];
+  failureTools: string[];
+}
+
 /** Build the user prompt for full body generation. */
 export function buildBodyGenerationPrompt(
   currentContent: string,
@@ -44,6 +53,7 @@ export function buildBodyGenerationPrompt(
   missedQueries: string[],
   skillName: string,
   fewShotExamples?: string[],
+  executionContext?: ExecutionContext,
 ): string {
   const patternLines = failurePatterns.map((p) => {
     const queries = p.missed_queries.map((q) => `    - "${q}"`).join("\n");
@@ -66,6 +76,11 @@ export function buildBodyGenerationPrompt(
   const feedbackSection =
     feedbackLines.length > 0 ? `\n\nStructured Failure Analysis:\n${feedbackLines.join("\n")}` : "";
 
+  // Build execution telemetry section if provided
+  const executionSection = executionContext
+    ? `\n\nExecution Profile (from recent sessions using this skill):\n  Average tool calls per session: ${executionContext.avgToolCalls.toFixed(1)}\n  Average errors per session: ${executionContext.avgErrors.toFixed(1)}\n  Average assistant turns: ${executionContext.avgTurns.toFixed(1)}\n  Most-used tools in successful sessions: ${executionContext.commonTools.join(", ") || "none"}\n  Tools correlated with failures: ${executionContext.failureTools.join(", ") || "none"}`
+    : "";
+
   // Build few-shot examples section if provided
   const fewShotSection =
     fewShotExamples && fewShotExamples.length > 0
@@ -81,7 +96,7 @@ Failure Patterns:
 ${patternLines.join("\n\n")}
 
 All Missed Queries:
-${missedLines}${feedbackSection}${fewShotSection}
+${missedLines}${feedbackSection}${executionSection}${fewShotSection}
 
 Generate an improved full body for the "${skillName}" skill that would correctly handle the missed queries listed above. The body should include everything below the # Title line: description, ## Workflow Routing table, and any other sections. Output ONLY a JSON object with "proposed_body", "rationale", and "confidence" fields.`;
 }
@@ -144,6 +159,7 @@ export async function generateBodyProposal(
   agent: string,
   modelFlag?: string,
   fewShotExamples?: string[],
+  executionContext?: ExecutionContext,
 ): Promise<BodyEvolutionProposal> {
   const prompt = buildBodyGenerationPrompt(
     currentContent,
@@ -151,6 +167,7 @@ export async function generateBodyProposal(
     missedQueries,
     skillName,
     fewShotExamples,
+    executionContext,
   );
   const rawResponse = await callLlm(BODY_GENERATOR_SYSTEM, prompt, agent, modelFlag);
   const { proposed_body, rationale, confidence } = parseBodyProposalResponse(rawResponse);

package/cli/selftune/evolution/propose-description.ts

@@ -36,12 +36,22 @@ Do NOT include any text outside the JSON object.`;
 // Prompt builder
 // ---------------------------------------------------------------------------
 
+/** Aggregate session quality metrics passed into proposal prompts. */
+export interface AggregateMetrics {
+  mean_score: number;
+  score_std_dev: number;
+  failed_session_rate: number;
+  mean_errors: number;
+  total_graded: number;
+}
+
 /** Build the user prompt for the LLM with context about failures. */
 export function buildProposalPrompt(
   currentDescription: string,
   failurePatterns: FailurePattern[],
   missedQueries: string[],
   skillName: string,
+  aggregateMetrics?: AggregateMetrics,
 ): string {
   const patternLines = failurePatterns.map((p) => {
     const queries = p.missed_queries.map((q) => `    - "${q}"`).join("\n");
@@ -67,6 +77,10 @@ export function buildProposalPrompt(
   const feedbackSection =
     feedbackLines.length > 0 ? `\n\nStructured Failure Analysis:\n${feedbackLines.join("\n")}` : "";
 
+  const metricsSection = aggregateMetrics
+    ? `\n\nSession Quality Context:\n  Mean grading score: ${aggregateMetrics.mean_score.toFixed(2)}/1.0 (σ=${aggregateMetrics.score_std_dev.toFixed(2)})\n  Failed session rate: ${(aggregateMetrics.failed_session_rate * 100).toFixed(0)}%\n  Mean execution errors per session: ${aggregateMetrics.mean_errors.toFixed(1)}\n  Sessions graded: ${aggregateMetrics.total_graded}`
+    : "";
+
   return `Skill Name: ${skillName}
 
 Current Description:
@@ -76,7 +90,7 @@ Failure Patterns:
 ${patternLines.join("\n\n")}
 
 All Missed Queries:
-${missedLines}${feedbackSection}
+${missedLines}${feedbackSection}${metricsSection}
 
 Propose an improved description for the "${skillName}" skill that would correctly route the missed queries listed above. Output ONLY a JSON object with "proposed_description", "rationale", and "confidence" fields.`;
 }
@@ -142,6 +156,7 @@ export async function generateMultipleProposals(
   agent: string,
   count = 3,
   modelFlag?: string,
+  aggregateMetrics?: AggregateMetrics,
 ): Promise<EvolutionProposal[]> {
   const variations = buildPromptVariations(
     currentDescription,
@@ -149,6 +164,7 @@ export async function generateMultipleProposals(
     missedQueries,
     skillName,
     count,
+    aggregateMetrics,
   );
 
   const proposals = await Promise.all(
@@ -187,6 +203,7 @@ export function buildPromptVariations(
   missedQueries: string[],
   skillName: string,
   count: number,
+  aggregateMetrics?: AggregateMetrics,
 ): string[] {
   const biases: string[] = [
     "Focus especially on improving explicit invocation (direct mentions of the skill).",
@@ -199,6 +216,7 @@ export function buildPromptVariations(
     failurePatterns,
     missedQueries,
     skillName,
+    aggregateMetrics,
   );
   const variations: string[] = [];
 
@@ -219,8 +237,15 @@ export async function generateProposal(
   skillPath: string,
   agent: string,
   modelFlag?: string,
+  aggregateMetrics?: AggregateMetrics,
 ): Promise<EvolutionProposal> {
-  const prompt = buildProposalPrompt(currentDescription, failurePatterns, missedQueries, skillName);
+  const prompt = buildProposalPrompt(
+    currentDescription,
+    failurePatterns,
+    missedQueries,
+    skillName,
+    aggregateMetrics,
+  );
   const rawResponse = await callLlm(PROPOSER_SYSTEM, prompt, agent, modelFlag);
   const { proposed_description, rationale, confidence } = parseProposalResponse(rawResponse);
 

package/cli/selftune/evolution/rollback.ts

@@ -24,7 +24,7 @@ export interface RollbackOptions {
   skillName: string;
   skillPath: string;
   proposalId?: string; // rollback specific proposal, or last deployed
-  logPath?: string; // optional override for audit log path (testing)
+  logPath?: string; // deprecated — ignored, kept for backward compat
 }
 
 export interface RollbackResult {
@@ -71,8 +71,8 @@ function findLatestBackup(skillPath: string): string | null {
  * Find the "created" audit entry for a given proposal ID and extract
  * the original_description from its details field.
  */
-function findOriginalFromAudit(proposalId: string, logPath?: string): string | null {
-  const entries = readAuditTrail(undefined, logPath);
+function findOriginalFromAudit(proposalId: string): string | null {
+  const entries = readAuditTrail();
   const createdEntry = entries.find((e) => e.proposal_id === proposalId && e.action === "created");
   if (!createdEntry) return null;
 
@@ -90,12 +90,8 @@ function findOriginalFromAudit(proposalId: string, logPath?: string): string | n
 /**
  * Find the deployed audit entry for a specific proposal ID.
  */
-function findDeployedEntry(
-  proposalId: string,
-  skillName: string,
-  logPath?: string,
-): EvolutionAuditEntry | null {
-  const entries = readAuditTrail(skillName, logPath);
+function findDeployedEntry(proposalId: string, skillName: string): EvolutionAuditEntry | null {
+  const entries = readAuditTrail(skillName);
   return entries.find((e) => e.proposal_id === proposalId && e.action === "deployed") ?? null;
 }
 
@@ -104,7 +100,7 @@ function findDeployedEntry(
 // ---------------------------------------------------------------------------
 
 export async function rollback(options: RollbackOptions): Promise<RollbackResult> {
-  const { skillName, skillPath, proposalId, logPath } = options;
+  const { skillName, skillPath, proposalId } = options;
 
   const noRollback = (reason: string): RollbackResult => ({
     rolledBack: false,
@@ -123,14 +119,14 @@ export async function rollback(options: RollbackOptions): Promise<RollbackResult
 
   if (proposalId) {
     // Verify the specific proposal exists in audit trail
-    const entry = findDeployedEntry(proposalId, skillName, logPath);
+    const entry = findDeployedEntry(proposalId, skillName);
     if (!entry) {
       return noRollback(`Proposal ${proposalId} not found as deployed entry in audit trail`);
     }
     targetProposalId = proposalId;
   } else {
     // Use the most recent deployed proposal
-    const lastDeployed = getLastDeployedProposal(skillName, logPath);
+    const lastDeployed = getLastDeployedProposal(skillName);
     if (!lastDeployed) {
       return noRollback(`No deployed proposal found for skill "${skillName}"`);
     }
@@ -152,7 +148,7 @@ export async function rollback(options: RollbackOptions): Promise<RollbackResult
       action: "rolled_back",
       details: `Rolled back ${skillName} from backup file`,
     };
-    appendAuditEntry(auditEntry, logPath);
+    appendAuditEntry(auditEntry);
 
     const backupResult: RollbackResult = {
       rolledBack: true,
@@ -170,7 +166,7 @@ export async function rollback(options: RollbackOptions): Promise<RollbackResult
   }
 
   // Strategy 2: Restore from audit trail's created entry (description only)
-  const originalFromAudit = findOriginalFromAudit(targetProposalId, logPath);
+  const originalFromAudit = findOriginalFromAudit(targetProposalId);
   if (originalFromAudit) {
     // Replace only the description section in SKILL.md, preserving structure
     const currentContent = readFileSync(skillPath, "utf-8");
@@ -184,7 +180,7 @@ export async function rollback(options: RollbackOptions): Promise<RollbackResult
       action: "rolled_back",
       details: `Rolled back ${skillName} from audit trail`,
     };
-    appendAuditEntry(auditEntry, logPath);
+    appendAuditEntry(auditEntry);
 
     const auditResult: RollbackResult = {
       rolledBack: true,