@jinn-network/client 0.1.8 → 0.1.9-canary.023faefb

package/dist/bin/jinn-distil-mcp.js

@@ -0,0 +1,813 @@
+#!/usr/bin/env node
+
+// packages/harness-layer/src/bin/jinn-distil-mcp.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// packages/harness-layer/src/distil-mcp-server.ts
+import { spawn } from "node:child_process";
+import { existsSync as existsSync2, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join as join3 } from "node:path";
+import { fileURLToPath } from "node:url";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z as z5 } from "zod/v3";
+
+// packages/harness-layer/src/distil-captures.ts
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+// packages/harness-layer/src/capture.ts
+import { z as z2 } from "zod";
+
+// src/trajectory/scrub/openredaction-stage.ts
+import { OpenRedaction } from "openredaction";
+
+// src/trajectory/scrub/secretlint-stage.ts
+import { lintSource } from "@secretlint/core";
+import { creator } from "@secretlint/secretlint-rule-preset-recommend";
+
+// src/trajectory/hash-chain.ts
+import { keccak256, toBytes } from "viem";
+
+// src/harnesses/engine/canonical-json.ts
+import canonicalize from "canonicalize";
+
+// packages/harness-layer/src/envelope.ts
+import { z } from "zod";
+var TRACE_ENVELOPE_SCHEMA_VERSION = "jinn.trace-envelope.v0";
+var MAX_STEPS = 512;
+var MAX_STEP_ATTRIBUTES_BYTES = 16 * 1024;
+var MAX_DISTRIBUTION_TAGS = 16;
+var VERIFIABILITY_TIERS = [
+  "user-accepted",
+  "tests-passed",
+  "evaluator-verified"
+];
+var VerifiabilityTierSchema = z.enum(VERIFIABILITY_TIERS);
+var OutcomeStatusSchema = z.enum(["completed", "failed", "abandoned"]);
+var UnixNanoSchema = z.string().regex(/^\d+$/, "unix-nanosecond digit string");
+var TrimmedString = (max) => z.string().min(1).max(max).regex(/^\S(.*\S)?$/s, "no surrounding whitespace");
+var TraceStepSchema = z.strictObject({
+  spanId: z.string().min(1),
+  parentSpanId: z.string().min(1).nullable(),
+  name: z.string().min(1),
+  startTimeUnixNano: UnixNanoSchema,
+  endTimeUnixNano: UnixNanoSchema,
+  attributes: z.record(z.string(), z.unknown()).superRefine((attrs, ctx) => {
+    let serialised;
+    try {
+      serialised = JSON.stringify(attrs);
+    } catch {
+      ctx.addIssue({ code: "custom", message: "attributes must be JSON-serialisable" });
+      return;
+    }
+    const bytes = Buffer.byteLength(serialised, "utf8");
+    if (bytes > MAX_STEP_ATTRIBUTES_BYTES) {
+      ctx.addIssue({
+        code: "custom",
+        message: `attributes serialise to ${bytes} bytes (max ${MAX_STEP_ATTRIBUTES_BYTES})`
+      });
+    }
+  }),
+  redactedKeys: z.array(z.string().min(1)),
+  /**
+   * Which attribute keys the capture→envelope pipeline truncated to fit
+   * `MAX_STEP_ATTRIBUTES_BYTES` — the visible truncation receipt, sibling
+   * to `redactedKeys` (2026-07-02 schema review, Q4).
+   */
+  truncatedKeys: z.array(z.string().min(1)).optional()
+});
+var TraceEnvelopeV0Schema = z.strictObject({
+  /** Migration gate — v1 readers reject/route on this. */
+  schemaVersion: z.literal(TRACE_ENVELOPE_SCHEMA_VERSION),
+  /** Capture-session identity: ledger correlation + dedup. */
+  session: z.strictObject({
+    sessionId: z.string().min(1).max(128),
+    capturedAt: z.iso.datetime()
+  }),
+  /** What the user was doing — the demand signal (spec §5). */
+  task: z.strictObject({
+    /** Scrubbed one-line descriptor of the task. */
+    summary: TrimmedString(500),
+    /**
+     * Freeform — no fixed taxonomy; clustering is inferred server-side.
+     * At least one tag: an untagged envelope is invisible to the signal.
+     */
+    distributionTags: z.array(TrimmedString(64)).min(1).max(MAX_DISTRIBUTION_TAGS)
+  }),
+  /** Config-diversity fingerprint (spec §5): harness, model, tools. */
+  environment: z.strictObject({
+    harness: z.strictObject({
+      name: z.string().min(1),
+      version: z.string().min(1)
+    }),
+    model: z.string().min(1),
+    /** Tool names only — never tool configs or arguments. */
+    tools: z.array(z.string().min(1).max(128)).max(64)
+  }),
+  /** The compressed trace body — the evidence itself. */
+  steps: z.array(TraceStepSchema).min(1).max(MAX_STEPS),
+  /** What happened, and how the status was established. */
+  outcome: z.strictObject({
+    status: OutcomeStatusSchema,
+    /**
+     * How the recorded status was established — the anti-farming line the
+     * activity checker counts against. Qualifies the status, so failed
+     * tasks carry a tier too.
+     */
+    verifiabilityTier: VerifiabilityTierSchema,
+    summary: TrimmedString(500).optional()
+  }),
+  /** What the task cost to run — the §8 capability-gate metric. */
+  cost: z.strictObject({
+    durationMs: z.number().int().nonnegative(),
+    tokens: z.strictObject({
+      input: z.number().int().nonnegative(),
+      output: z.number().int().nonnegative()
+    }).optional(),
+    /** Decimal string — money is never IEEE-754. An estimate, named as such. */
+    usdEstimate: z.string().regex(/^\d+(\.\d+)?$/).optional()
+  }),
+  /**
+   * The publish gate (spec §5), fail-closed at the type level: both flags
+   * are literal `true`, so an envelope representing an unconsented or
+   * unscrubbed trace is not constructible.
+   */
+  consent: z.strictObject({
+    /** First-run consent given AND no per-task veto on this trace. */
+    contributionConsent: z.literal(true),
+    /** The mandatory scrub pipeline completed on this trace. */
+    scrubCompleted: z.literal(true)
+  }),
+  /**
+   * `contributed` = real user trace; `imported` = seed (spec §7).
+   * The distribution signal excludes `imported`.
+   */
+  provenance: z.enum(["contributed", "imported"])
+});
+
+// packages/harness-layer/src/capture.ts
+var UnixNanoSchema2 = z2.string().regex(/^\d+$/, "unix-nanosecond digit string");
+var CapturedTaskSchema = z2.strictObject({
+  session: z2.strictObject({
+    sessionId: z2.string().min(1).max(128),
+    capturedAt: z2.iso.datetime()
+  }),
+  task: z2.strictObject({
+    summary: z2.string().min(1),
+    distributionTags: z2.array(z2.string().min(1)).min(1)
+  }),
+  environment: z2.strictObject({
+    harness: z2.strictObject({
+      name: z2.string().min(1),
+      version: z2.string().min(1)
+    }),
+    model: z2.string().min(1),
+    tools: z2.array(z2.string().min(1))
+  }),
+  steps: z2.array(z2.strictObject({
+    spanId: z2.string().min(1),
+    parentSpanId: z2.string().min(1).nullable(),
+    name: z2.string().min(1),
+    startTimeUnixNano: UnixNanoSchema2,
+    endTimeUnixNano: UnixNanoSchema2,
+    attributes: z2.record(z2.string(), z2.unknown()),
+    /** Keys already redacted at ingest, if the capture recorded any. */
+    redactedKeys: z2.array(z2.string().min(1)).default([])
+  })).min(1),
+  outcome: z2.strictObject({
+    status: OutcomeStatusSchema,
+    verifiabilityTier: VerifiabilityTierSchema,
+    summary: z2.string().min(1).optional()
+  }),
+  cost: z2.strictObject({
+    durationMs: z2.number().int().nonnegative(),
+    tokens: z2.strictObject({
+      input: z2.number().int().nonnegative(),
+      output: z2.number().int().nonnegative()
+    }).optional(),
+    usdEstimate: z2.string().regex(/^\d+(\.\d+)?$/).optional()
+  }),
+  provenance: z2.enum(["contributed", "imported"]).default("contributed")
+});
+function parseCapturedTask(input) {
+  return CapturedTaskSchema.parse(input);
+}
+
+// packages/harness-layer/src/skill-package.ts
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { z as z4 } from "zod";
+
+// src/types/skill-artifact.ts
+import { z as z3 } from "zod/v3";
+var SKILL_ARTIFACT_TYPE = "jinn.skill.v1";
+var MAX_SKILL_FILES = 64;
+var MAX_SKILL_TOTAL_DECODED_BYTES = 1024 * 1024;
+var HexAddressSchema = z3.string().regex(/^0x[0-9a-fA-F]*$/);
+var CompanionPathSchema = z3.string().min(1).refine(
+  (p) => !p.includes("\\") && !p.startsWith("/") && !/^[A-Za-z]:/.test(p) && !p.split("/").includes("..") && !p.split("/").includes(""),
+  { message: "companion file path must be a relative, traversal-free POSIX path" }
+);
+var SkillCompanionFileSchema = z3.object({
+  path: CompanionPathSchema,
+  contentBase64: z3.string(),
+  sha256: z3.string().regex(/^[0-9a-f]{64}$/)
+});
+var SkillProvenanceSchema = z3.object({
+  kind: z3.enum(["imported", "distilled"]),
+  /**
+   * Envelope CIDs the skill was distilled from ([] for seed imports).
+   * The "distilled from N traces" count is this array's length — never
+   * stored separately (anti-drift).
+   */
+  sourceEnvelopeCids: z3.array(z3.string().min(1)),
+  operator: z3.object({ safeAddress: HexAddressSchema }),
+  solverType: z3.string().min(1).optional(),
+  /** Seed attribution, mirroring the seeded trace's `seed.attribution`. */
+  seed: z3.object({
+    skill: z3.string().min(1),
+    source: z3.string().min(1),
+    licence: z3.string().nullable()
+  }).optional(),
+  // --- distilled-skill fields (DR-2026-07-06, additive; producer is
+  // publishSkill() in client/packages/harness-layer/src/publish-skill.ts) ---
+  /**
+   * Success→strategic-pattern, failure→lesson, both-polarity→contrastive
+   * (spec §7, D10 + v0.5), or cross-instance corroboration→cross-instance
+   * (stage-2 meta-distill). `contrastive` and `cross-instance` are additive
+   * enum values: strict consumers (`extractSkill`) reject them until upgraded
+   * — acceptable at testnet volume, named in the spec.
+   */
+  skillKind: z3.enum(["strategic-pattern", "failure-lesson", "contrastive", "cross-instance"]).optional(),
+  /** SHA-256 of the exact distill prompt that produced the skill (auditability, D4). */
+  distillPromptSha256: z3.string().regex(/^[0-9a-f]{64}$/).optional(),
+  /** Task-distribution the skill targets (e.g. 'coding'). */
+  distribution: z3.string().min(1).optional(),
+  /** Verifiability tier of the source evidence (e.g. 'evaluator-verified'). */
+  verifiabilityTier: z3.string().min(1).optional(),
+  /**
+   * The model that ran distillation (spec §5, v0.5). Distillation quality is
+   * model-sensitive; recording it makes a skill's quality auditable.
+   */
+  distillModel: z3.string().min(1).optional(),
+  /**
+   * Deterministic `ceil(utf8 chars / 4)` token estimates of the distiller
+   * input and the emitted body (spec §5, v0.5). The pair records the
+   * compression ratio (SkillRL operates at 10–20×); an auditable estimate
+   * serves that purpose better than an unreproducible exact count (the LLM
+   * port reports no usage).
+   */
+  evidenceTokens: z3.number().int().nonnegative().optional(),
+  skillTokens: z3.number().int().nonnegative().optional(),
+  // --- supersede lineage (issue #1462, additive) ---
+  /**
+   * Envelope/manifest CID of a prior skill record this one replaces — the same
+   * identity space as `sourceEnvelopeCids` and a search-hit `ref`. Honored at
+   * read time ONLY when this record's operator matches the superseded record's
+   * operator (cross-operator supersedes are ignored); see the read-path head
+   * resolver in client/packages/harness-layer/src/consume.ts.
+   */
+  supersedes: z3.string().min(1).optional(),
+  /**
+   * Pure retirement marker: retires this record's `supersedes` target with no
+   * replacement and hides this record itself from discovery. A deprecation
+   * record carries no successor skill content.
+   */
+  deprecates: z3.boolean().optional()
+});
+function base64DecodedBytes(b64) {
+  const padding = b64.endsWith("==") ? 2 : b64.endsWith("=") ? 1 : 0;
+  return Math.max(0, Math.floor(b64.length * 3 / 4) - padding);
+}
+var SkillArtifactV1Schema = z3.object({
+  schemaVersion: z3.literal(SKILL_ARTIFACT_TYPE),
+  skill: z3.object({
+    name: z3.string().min(1),
+    description: z3.string().optional(),
+    skillMd: z3.string().min(1)
+  }),
+  files: z3.array(SkillCompanionFileSchema).max(MAX_SKILL_FILES),
+  provenance: SkillProvenanceSchema
+}).refine(
+  (a) => new TextEncoder().encode(a.skill.skillMd).length + a.files.reduce((n, f) => n + base64DecodedBytes(f.contentBase64), 0) <= MAX_SKILL_TOTAL_DECODED_BYTES,
+  { message: "skill artifact exceeds the 1 MiB total decoded-content cap" }
+);
+
+// packages/harness-layer/src/skill-package.ts
+var SkillPackageMetaSchema = z4.strictObject({
+  schema: z4.literal(SKILL_ARTIFACT_TYPE),
+  distribution: z4.string().min(1),
+  verifiabilityTier: z4.string().min(1),
+  distilledFrom: z4.number().int().nonnegative(),
+  provenance: z4.array(z4.string().min(1)),
+  distillPromptSha256: z4.string().regex(/^[0-9a-f]{64}$/).optional(),
+  distilledAt: z4.string().optional(),
+  seedSource: z4.string().optional(),
+  skillKind: z4.enum(["strategic-pattern", "failure-lesson", "contrastive", "cross-instance"]).optional(),
+  status: z4.enum(["experimental", "stable", "deprecated"]).optional(),
+  evidenceTier: z4.enum(["single-example", "recurring-pattern", "contrastive", "user-confirmed", "stable", "deprecated"]).optional(),
+  sourceTools: z4.array(z4.string().min(1)).optional(),
+  targetTools: z4.array(z4.string().min(1)).optional(),
+  uses: z4.number().int().nonnegative().optional(),
+  positiveFeedback: z4.number().int().nonnegative().optional(),
+  negativeFeedback: z4.number().int().nonnegative().optional(),
+  // Auditability (spec §5, v0.5): the distilling model + a deterministic
+  // ceil(chars/4) token estimate of input vs body (the compression ratio).
+  distillModel: z4.string().min(1).optional(),
+  evidenceTokens: z4.number().int().nonnegative().optional(),
+  skillTokens: z4.number().int().nonnegative().optional()
+}).refine((m) => m.distilledFrom <= m.provenance.length && (m.provenance.length === 0 || m.distilledFrom >= 1), {
+  message: "distilledFrom must be between 1 and provenance.length (distinct-instance corroboration \u2264 audited traces)"
+});
+
+// packages/harness-layer/src/distil-captures.ts
+var DEFAULT_CAPTURES_DIR = join(homedir(), ".jinn-client", "harness-layer", "captures");
+var DEFAULT_SKILLS_INSTALL_DIR = join(homedir(), ".jinn-client", "harness-layer", "skills");
+var DEFAULT_DISTIL_CAPTURE_LIMIT = 50;
+function loadRecentCaptures(dir, limit) {
+  if (!existsSync(dir)) return [];
+  const parsed = [];
+  for (const file of readdirSync(dir)) {
+    if (!file.endsWith(".json")) continue;
+    try {
+      parsed.push(parseCapturedTask(JSON.parse(readFileSync(join(dir, file), "utf-8"))));
+    } catch (err) {
+      console.warn(
+        `[distil] skipping malformed capture file ${file}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  parsed.sort((a, b) => b.session.capturedAt.localeCompare(a.session.capturedAt));
+  return parsed.slice(0, limit);
+}
+
+// packages/harness-layer/src/distil-traces.ts
+function uniq(values) {
+  return [...new Set([...values].filter((v) => typeof v === "string" && v.trim() !== "").map((v) => v.trim()))];
+}
+function oneLine(value, max = 240) {
+  if (typeof value !== "string") return void 0;
+  const text = value.replace(/\s+/g, " ").trim();
+  if (!text) return void 0;
+  return text.length > max ? `${text.slice(0, max - 1)}\u2026` : text;
+}
+function parseJsonObject(value) {
+  if (typeof value !== "string") return null;
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function commandFromStep(step) {
+  const args = parseJsonObject(step.attributes["tool.args"]);
+  return oneLine(args?.["command"] ?? args?.["cmd"] ?? step.attributes["command"]);
+}
+function fileFromStep(step) {
+  const args = parseJsonObject(step.attributes["tool.args"]);
+  return oneLine(step.attributes["file.path"] ?? args?.["path"] ?? args?.["file"]);
+}
+function eventKind(step) {
+  return typeof step.attributes["jinn.capture.event.kind"] === "string" ? step.attributes["jinn.capture.event.kind"] : step.name;
+}
+function eventText(step) {
+  return oneLine(
+    step.attributes["message.content"] ?? step.attributes["tool.result"] ?? step.attributes["file.diff"] ?? commandFromStep(step) ?? fileFromStep(step)
+  );
+}
+function toolName(step) {
+  return oneLine(step.attributes["tool.name"]);
+}
+function traceId(task) {
+  return `local-capture:${task.session.sessionId}`;
+}
+function traceCardFromCapture(task) {
+  const commands = uniq(task.steps.map(commandFromStep));
+  const filesTouched = uniq(task.steps.map(fileFromStep));
+  const errorSnippets = uniq(task.steps.map((step) => {
+    const isError = step.attributes["tool.is_error"] === true || step.attributes["tool.is_error"] === "true";
+    return isError ? oneLine(step.attributes["tool.result"]) : void 0;
+  }));
+  const toolNames = uniq([
+    ...task.environment.tools,
+    ...task.steps.map(toolName)
+  ]);
+  const redactionFlags = task.steps.some((step) => step.redactedKeys.length > 0) ? ["redacted"] : [];
+  return {
+    traceId: traceId(task),
+    sessionId: task.session.sessionId,
+    sourceTool: task.environment.harness.name,
+    startedAt: task.session.capturedAt,
+    durationMs: task.cost.durationMs,
+    summary: task.task.summary,
+    tools: toolNames,
+    commands,
+    filesTouched,
+    errorSnippets,
+    outcome: task.outcome.status,
+    skillsUsed: [],
+    redactionFlags
+  };
+}
+function eventView(step, includeAttributes = false) {
+  const out = {
+    spanId: step.spanId,
+    kind: eventKind(step),
+    name: step.name
+  };
+  const text = eventText(step);
+  const tool = toolName(step);
+  if (text) out.text = text;
+  if (tool) out.toolName = tool;
+  if (includeAttributes) out.attributes = step.attributes;
+  return out;
+}
+function readTrace(task, opts) {
+  const base = { mode: opts.mode, traceId: traceId(task), summary: task.task.summary };
+  if (opts.mode === "summary") return base;
+  if (opts.mode === "full_transcript" && !opts.allowFullTranscript) {
+    throw new Error("full transcript reads require explicit allowFullTranscript=true");
+  }
+  const events = task.steps.map((step) => eventView(step, opts.mode === "full_transcript"));
+  if (opts.mode === "events" || opts.mode === "full_transcript") return { ...base, events };
+  if (opts.mode === "tool_calls") {
+    return {
+      ...base,
+      toolCalls: events.filter((event) => event.kind === "tool-call" || event.toolName !== void 0)
+    };
+  }
+  const q = opts.query?.toLowerCase();
+  const filtered = q ? events.filter((event) => JSON.stringify(event).toLowerCase().includes(q)) : events;
+  return { ...base, events: filtered.slice(0, opts.limit ?? 20) };
+}
+function cardText(card) {
+  return [
+    card.summary,
+    ...card.tools,
+    ...card.commands,
+    ...card.filesTouched,
+    ...card.errorSnippets,
+    card.outcome
+  ].join("\n").toLowerCase();
+}
+function searchTraceCards(cards, query) {
+  const matches = cards.filter((card) => {
+    if (query.query && !cardText(card).includes(query.query.toLowerCase())) return false;
+    if (query.command && !card.commands.some((c) => c.toLowerCase().includes(query.command.toLowerCase()))) return false;
+    if (query.file && !card.filesTouched.some((f) => f.toLowerCase().includes(query.file.toLowerCase()))) return false;
+    if (query.error && !card.errorSnippets.some((e) => e.toLowerCase().includes(query.error.toLowerCase()))) return false;
+    if (query.tool && !card.tools.some((t) => t.toLowerCase().includes(query.tool.toLowerCase()))) return false;
+    if (query.outcome && card.outcome !== query.outcome) return false;
+    return true;
+  });
+  return matches.sort((a, b) => b.startedAt.localeCompare(a.startedAt)).slice(0, query.limit ?? matches.length);
+}
+function estimateTokens(text) {
+  return Math.ceil(new TextEncoder().encode(text).length / 4);
+}
+function costFor(tokens) {
+  if (tokens < 2e4) return "low";
+  if (tokens < 8e4) return "medium";
+  return "high";
+}
+function grouped(cards, key) {
+  const out = /* @__PURE__ */ new Map();
+  for (const card of cards) {
+    for (const value of card[key]) {
+      const normalized = value.toLowerCase();
+      const group = out.get(normalized) ?? [];
+      group.push(card);
+      out.set(normalized, group);
+    }
+  }
+  return out;
+}
+function clusterTraceCards(cards) {
+  const candidates = [];
+  const addGroups = (label, key, groups, priority) => {
+    for (const [signal, group] of groups) {
+      if (group.length < 2) continue;
+      const tokenEstimate = estimateTokens(JSON.stringify(group));
+      candidates.push({
+        title: `${label}: ${group[0]?.[key === "errors" ? "errorSnippets" : key === "commands" ? "commands" : "filesTouched"].find((v) => v.toLowerCase() === signal) ?? signal}`,
+        traceIds: group.map((card) => card.traceId),
+        repeatedSignals: { [key]: [signal] },
+        evidenceTierEstimate: "recurring-pattern",
+        estimatedSourceTokens: tokenEstimate,
+        estimatedDistillCost: costFor(tokenEstimate),
+        privacyFlags: uniq(group.flatMap((card) => card.redactionFlags)),
+        priority
+      });
+    }
+  };
+  addGroups("Repeated error", "errors", grouped(cards, "errorSnippets"), 0);
+  addGroups("Repeated command", "commands", grouped(cards, "commands"), 1);
+  addGroups("Repeated file", "files", grouped(cards, "filesTouched"), 2);
+  if (candidates.length === 0 && cards.length === 1) {
+    const tokenEstimate = estimateTokens(JSON.stringify(cards[0]));
+    candidates.push({
+      title: cards[0].summary,
+      traceIds: [cards[0].traceId],
+      repeatedSignals: {},
+      evidenceTierEstimate: "single-example",
+      estimatedSourceTokens: tokenEstimate,
+      estimatedDistillCost: costFor(tokenEstimate),
+      privacyFlags: cards[0].redactionFlags,
+      priority: 3
+    });
+  }
+  return candidates.sort((a, b) => b.traceIds.length - a.traceIds.length || a.priority - b.priority || a.title.localeCompare(b.title)).map(({ priority, ...candidate }, index) => ({
+    candidateId: `local-candidate-${String(index + 1).padStart(3, "0")}`,
+    ...candidate
+  }));
+}
+
+// packages/harness-layer/src/distil-feedback.ts
+import { appendFileSync, mkdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { dirname, join as join2 } from "node:path";
+var DEFAULT_DISTIL_FEEDBACK_PATH = join2(homedir2(), ".jinn-client", "harness-layer", "distil-feedback.jsonl");
+function distilFeedbackPathFromEnv(env = process.env) {
+  return env["JINN_LAYER_DISTIL_FEEDBACK_PATH"] ?? DEFAULT_DISTIL_FEEDBACK_PATH;
+}
+function recordDistilFeedback(input, opts = {}) {
+  const record = {
+    schema: "jinn.distil.feedback.v1",
+    skillName: input.skillName,
+    verdict: input.verdict,
+    recordedAt: input.recordedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    ...input.sessionId ? { sessionId: input.sessionId } : {},
+    ...input.notes ? { notes: input.notes } : {},
+    ...input.acceptedChanges && input.acceptedChanges.length > 0 ? { acceptedChanges: input.acceptedChanges } : {}
+  };
+  const path = opts.path ?? distilFeedbackPathFromEnv(opts.env);
+  mkdirSync(dirname(path), { recursive: true, mode: 448 });
+  appendFileSync(path, `${JSON.stringify(record)}
+`, { mode: 384 });
+  return record;
+}
+
+// packages/harness-layer/src/distil-mcp-server.ts
+var traceReadModes = ["summary", "events", "tool_calls", "transcript_excerpt", "full_transcript"];
+function createDistilMcpServer(deps = {}) {
+  const server2 = new McpServer({
+    name: "jinn-local-distil",
+    version: "0.1.0"
+  });
+  server2.tool(
+    "distill_trace_search",
+    "Search local trace cards from the shared local distil capture directory. Use this before reading full traces; returns compact cards only.",
+    {
+      capturesDir: z5.string().optional().describe("Directory containing CapturedTask JSON files. Defaults to JINN_LAYER_CAPTURES_DIR or ~/.jinn-client/harness-layer/captures."),
+      limit: z5.number().int().positive().max(500).optional().describe("Maximum captures to load and maximum cards to return."),
+      query: z5.string().optional().describe("Free-text query across summary, tools, commands, files, errors, and outcome."),
+      command: z5.string().optional().describe("Command substring filter."),
+      file: z5.string().optional().describe("Touched-file substring filter."),
+      error: z5.string().optional().describe("Error substring filter."),
+      tool: z5.string().optional().describe("Tool-name substring filter."),
+      outcome: z5.enum(["completed", "failed", "abandoned"]).optional().describe("Outcome status filter.")
+    },
+    async (args) => {
+      const capturesDir = args.capturesDir ?? capturesDirFromEnv(deps.env);
+      const limit = args.limit ?? DEFAULT_DISTIL_CAPTURE_LIMIT;
+      const captures = loadRecentCaptures(capturesDir, limit);
+      const cards = searchTraceCards(captures.map(traceCardFromCapture), {
+        query: args.query,
+        command: args.command,
+        file: args.file,
+        error: args.error,
+        tool: args.tool,
+        outcome: args.outcome,
+        limit
+      });
+      return jsonResponse({ capturesDir, count: cards.length, cards });
+    }
+  );
+  server2.tool(
+    "distill_trace_read",
+    "Read a selected local trace by traceId or sessionId. Prefer summary, transcript_excerpt, or tool_calls before requesting full_transcript.",
+    {
+      capturesDir: z5.string().optional().describe("Directory containing CapturedTask JSON files."),
+      limit: z5.number().int().positive().max(500).optional().describe("Maximum captures to load while locating the trace."),
+      traceId: z5.string().optional().describe("Trace id returned by distill_trace_search, e.g. local-capture:<sessionId>."),
+      sessionId: z5.string().optional().describe("Raw session id when traceId is not available."),
+      mode: z5.enum(traceReadModes).optional().describe("Read mode. full_transcript requires allowFullTranscript=true."),
+      query: z5.string().optional().describe("Optional excerpt filter for transcript_excerpt mode."),
+      readLimit: z5.number().int().positive().max(200).optional().describe("Maximum events returned for transcript_excerpt mode."),
+      allowFullTranscript: z5.boolean().optional().describe("Required explicit opt-in for full_transcript reads.")
+    },
+    async (args) => {
+      const capturesDir = args.capturesDir ?? capturesDirFromEnv(deps.env);
+      const captures = loadRecentCaptures(capturesDir, args.limit ?? DEFAULT_DISTIL_CAPTURE_LIMIT);
+      const capture = findCapture(captures, { traceId: args.traceId, sessionId: args.sessionId });
+      if (!capture) return errorResponse(`Trace not found: ${args.traceId ?? args.sessionId ?? "(missing id)"}`);
+      try {
+        return jsonResponse(readTrace(capture, {
+          mode: args.mode ?? "summary",
+          query: args.query,
+          limit: args.readLimit,
+          allowFullTranscript: args.allowFullTranscript
+        }));
+      } catch (err) {
+        return errorResponse(err instanceof Error ? err.message : String(err));
+      }
+    }
+  );
+  server2.tool(
+    "distill_trace_cluster",
+    "Group local trace cards into candidate skill opportunities using repeated commands, files, and error signals. This is a cheap pre-distill scan.",
+    {
+      capturesDir: z5.string().optional().describe("Directory containing CapturedTask JSON files."),
+      limit: z5.number().int().positive().max(500).optional().describe("Maximum captures to load.")
+    },
+    async (args) => {
+      const capturesDir = args.capturesDir ?? capturesDirFromEnv(deps.env);
+      const captures = loadRecentCaptures(capturesDir, args.limit ?? DEFAULT_DISTIL_CAPTURE_LIMIT);
+      const candidates = clusterTraceCards(captures.map(traceCardFromCapture));
+      return jsonResponse({ capturesDir, count: candidates.length, candidates });
+    }
+  );
+  server2.tool(
+    "distill_local",
+    "Run local skill distillation over captured traces by delegating to jinn-layer distil. Requires confirm:true because it can call an LLM and write staged or installed skills.",
+    {
+      confirm: z5.boolean().optional().describe("Must be true to execute. Omit or false to receive a preview envelope."),
+      capturesDir: z5.string().optional().describe("Directory containing CapturedTask JSON files."),
+      out: z5.string().optional().describe("Output directory for distilled skills."),
+      limit: z5.number().int().positive().max(500).optional().describe("Maximum captures to distill."),
+      traceIds: z5.array(z5.string()).optional().describe("Optional selected trace IDs to distill, as returned by distill_trace_search or distill_trace_cluster."),
+      sessionIds: z5.array(z5.string()).optional().describe("Optional selected raw session IDs to distill."),
+      install: z5.string().optional().describe("Install choice passed to --install: all, none, or a specific skill name."),
+      resume: z5.boolean().optional().describe("Pass --resume so already-covered sessions are skipped."),
+      distiller: z5.enum(["claude", "codex"]).optional().describe("LLM provider to use for the distiller pass."),
+      distillerModel: z5.string().optional().describe("Distiller model name. This is separate from the runtime model recorded in the skill.")
+    },
+    async (args) => {
+      if (!args.confirm) {
+        return jsonResponse({
+          schemaVersion: 1,
+          status: "preview",
+          tool: "distill_local",
+          description: "Run local distillation over captured traces.",
+          effects: [
+            "Reads local captured-task JSON files.",
+            "Calls the selected user LLM provider through the existing jinn-layer distil flow.",
+            "Writes distilled skill packages under the output/staging directory and may install selected skills."
+          ],
+          followUp: {
+            tool: "distill_local",
+            arguments: { ...args, confirm: true }
+          }
+        });
+      }
+      return runLocalDistil({
+        capturesDir: args.capturesDir,
+        out: args.out,
+        limit: args.limit,
+        traceIds: args.traceIds,
+        sessionIds: args.sessionIds,
+        install: args.install,
+        resume: args.resume,
+        distiller: args.distiller,
+        distillerModel: args.distillerModel
+      }, deps);
+    }
+  );
+  server2.tool(
+    "distill_feedback_record",
+    "Record local user feedback for an experimental distilled skill. Use this after a later session uses the skill and the user accepts a helped/hurt/mixed/unused verdict.",
+    {
+      skillName: z5.string().min(1).describe("Distilled skill name."),
+      verdict: z5.enum(["helped", "hurt", "mixed", "unused"]).describe("User-visible outcome of using the skill."),
+      sessionId: z5.string().optional().describe("Session where the skill was used, if known."),
+      notes: z5.string().optional().describe("Short user-approved note about what to improve or preserve."),
+      acceptedChanges: z5.array(z5.string()).optional().describe("Concrete user-approved changes to apply in a later skill improvement pass."),
+      feedbackPath: z5.string().optional().describe("Override feedback JSONL path. Defaults to JINN_LAYER_DISTIL_FEEDBACK_PATH or ~/.jinn-client/harness-layer/distil-feedback.jsonl.")
+    },
+    async (args) => {
+      const record = recordDistilFeedback({
+        skillName: args.skillName,
+        verdict: args.verdict,
+        ...args.sessionId ? { sessionId: args.sessionId } : {},
+        ...args.notes ? { notes: args.notes } : {},
+        ...args.acceptedChanges ? { acceptedChanges: args.acceptedChanges } : {}
+      }, {
+        ...args.feedbackPath ? { path: args.feedbackPath } : {},
+        ...deps.env ? { env: deps.env } : {}
+      });
+      return jsonResponse({ recorded: record });
+    }
+  );
+  return server2;
+}
+async function runLocalDistil(args, deps = {}) {
+  const resolved = resolveJinnLayerCommand(deps.env);
+  const selected = materializeSelectedCaptures(args, deps.env);
+  if (selected.error) return errorResponse(selected.error);
+  const argv = [
+    ...resolved.prefixArgs,
+    "distil",
+    "--where",
+    "local",
+    "--json"
+  ];
+  const capturesDir = selected.capturesDir ?? args.capturesDir;
+  if (capturesDir) argv.push("--captures", capturesDir);
+  if (args.out) argv.push("--out", args.out);
+  if (args.limit !== void 0) argv.push("--limit", String(args.limit));
+  if (args.install) argv.push("--install", args.install);
+  if (args.resume) argv.push("--resume");
+  if (args.distiller) argv.push("--distiller", args.distiller);
+  if (args.distillerModel) argv.push("--distiller-model", args.distillerModel);
+  const spawnFn = deps.spawn ?? spawn;
+  const child = spawnFn(resolved.command, argv, {
+    env: { ...process.env, ...deps.env ?? {} },
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  try {
+    const result = await collectChild(child);
+    return jsonResponse({
+      command: [basename(resolved.command), ...argv],
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      ...selected.traceCount !== void 0 ? { selectedTraceCount: selected.traceCount } : {}
+    }, result.exitCode === 0 ? void 0 : true);
+  } finally {
+    if (selected.tempDir) rmSync(selected.tempDir, { recursive: true, force: true });
+  }
+}
+function jsonResponse(value, isError) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(value) }],
+    ...isError ? { isError } : {}
+  };
+}
+function errorResponse(message) {
+  return jsonResponse({ error: { message } }, true);
+}
+function capturesDirFromEnv(env = process.env) {
+  return env["JINN_LAYER_CAPTURES_DIR"] ?? DEFAULT_CAPTURES_DIR;
+}
+function findCapture(captures, ids) {
+  const sessionId = ids.sessionId ?? ids.traceId?.replace(/^local-capture:/, "");
+  if (!sessionId) return void 0;
+  return captures.find((capture) => capture.session.sessionId === sessionId);
+}
+function resolveJinnLayerCommand(env = process.env) {
+  if (env["JINN_LAYER_BIN"]) return { command: env["JINN_LAYER_BIN"], prefixArgs: [] };
+  const sibling = fileURLToPath(new URL("./jinn-layer.js", import.meta.url));
+  if (existsSync2(sibling)) return { command: process.execPath, prefixArgs: [sibling] };
+  return { command: "jinn-layer", prefixArgs: [] };
+}
+function materializeSelectedCaptures(args, env = process.env) {
+  const selectedIds = new Set([
+    ...args.sessionIds ?? [],
+    ...(args.traceIds ?? []).map((id) => id.replace(/^local-capture:/, ""))
+  ].filter((id) => id.trim() !== ""));
+  if (selectedIds.size === 0) return {};
+  const sourceDir = args.capturesDir ?? capturesDirFromEnv(env);
+  const captures = loadRecentCaptures(sourceDir, args.limit ?? DEFAULT_DISTIL_CAPTURE_LIMIT).filter((capture) => selectedIds.has(capture.session.sessionId));
+  if (captures.length === 0) {
+    return { error: `No selected traces found in ${sourceDir}` };
+  }
+  const tempDir = mkdtempSync(join3(tmpdir(), "jinn-distil-selected-"));
+  for (const capture of captures) {
+    writeFileSync(
+      join3(tempDir, `${safeFilePart(capture.session.sessionId)}.json`),
+      `${JSON.stringify(capture, null, 2)}
+`,
+      { mode: 384 }
+    );
+  }
+  return { capturesDir: tempDir, tempDir, traceCount: captures.length };
+}
+function safeFilePart(value) {
+  const safe = value.replace(/[^a-zA-Z0-9._-]/g, "_").slice(0, 128);
+  return safe || "capture";
+}
+function collectChild(child) {
+  return new Promise((resolve, reject) => {
+    let stdout = "";
+    let stderr = "";
+    child.stdout?.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    child.once("error", reject);
+    child.once("close", (code) => resolve({ exitCode: code, stdout, stderr }));
+  });
+}
+
+// packages/harness-layer/src/bin/jinn-distil-mcp.ts
+var server = createDistilMcpServer();
+var transport = new StdioServerTransport();
+server.connect(transport).catch((err) => {
+  console.error("[jinn-distil-mcp] failed to start");
+  console.error(err);
+  process.exit(1);
+});