@jinn-network/jinn-layer 0.1.0

package/dist/pipeline.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Distillation pipeline orchestrator (spec/2026-07-06-distillation-v1.md §6–§8).
+ *
+ * Composes the run-time loop end to end: verdict source → **bridge** (ledger →
+ * layer-1 evidence, both polarities, exclusion + dedup) → **gate + cluster**
+ * (eligible evidence grouped by distinct instance/tier) → **distill** (patterns
+ * + lessons → layer-2 skills). Every I/O boundary is an injected port, so the
+ * whole loop runs green under stubs (the Tier-0 dry-run) and swaps to the real
+ * adapters (verdict-source / fetchEvidence / claude distiller / publishSkill) +
+ * `ANTHROPIC_API_KEY` for a Tier-1 run with no code change.
+ *
+ * The bridge and distiller are decoupled in production through the corpus; here
+ * the pipeline captures each bridged envelope via the `publishEvidence` port and
+ * hands the same envelopes to clustering, so it reuses the tested `bridgeAttempts`
+ * (exclusion/dedup) without a corpus round-trip or a double fetch.
+ */
+import { type AttemptRef, type BridgeEvidence, type BridgeResult } from './bridge.js';
+import { type HarnessPublishDeps } from './publish.js';
+import { type TraceEnvelopeV0 } from './envelope.js';
+import { type MetaCluster } from './cluster.js';
+import { type DistillCluster, type DistillLLMOutput, type DistillResult, type MetaDistillLLMOutput, type MetaDistillResult } from './distill.js';
+import type { SkillPackage } from './skill-package.js';
+export interface PipelineDeps {
+    /** Ledger verdict-row source (both polarities). */
+    verdictSource: {
+        list: (args?: {
+            limit?: number;
+        }) => Promise<AttemptRef[]>;
+    };
+    /** Fetch the patch + task descriptor for an attempt. */
+    fetchEvidence: (ref: AttemptRef) => Promise<BridgeEvidence>;
+    /** Deps for the layer-1 publish (capture→publish). */
+    publishDeps: HarnessPublishDeps;
+    /** Bulk bridge records opt into a single manifest anchor; default stays per-record. */
+    anchorMode?: 'per-record' | 'manifest';
+    /** Add one explicit per-record control tx to a live manifest measurement run. */
+    measurePerRecordControl?: boolean;
+    /** The LLM distill port (jinn-skill-distill-prompt-v1 over a cluster). */
+    distill: (cluster: DistillCluster) => Promise<DistillLLMOutput>;
+    /** Publish a layer-2 skill package (Plan A publishSkill). */
+    publishSkill: (pkg: SkillPackage) => Promise<{
+        envelopeRef: string;
+        anchorTx: string | null;
+    }>;
+    /** Held-out slate (§12): excluded from the bridge AND the gate/cluster. */
+    slate: {
+        instanceIds: Set<string>;
+        repos?: Set<string>;
+    };
+    distribution?: string;
+    /** The distilling model, recorded in each skill's provenance (§5 auditability). */
+    distillModel?: string;
+    /** Enable stage-2 cross-instance meta-distill (issue #1463). Default off (opt-in). */
+    meta?: boolean;
+    /** The stage-2 meta LLM port. Required when `meta` is true. */
+    metaDistill?: (cluster: MetaCluster) => Promise<MetaDistillLLMOutput>;
+    /**
+     * Attempts retained per `(instance_id, polarity)` — the per-instance attempt
+     * group the distiller reasons over for group-relative distillation (#1478).
+     * Default 8. NOTE: for a group to be complete, `verdictSource.list` must
+     * return every attempt of the instance. Its no-limit default walks the full
+     * paged corpus; an explicit tight `limit` truncates in enrichment order and
+     * can split a group.
+     */
+    groupCap?: number;
+    limit?: number;
+    now?: () => Date;
+}
+export interface PipelineResult {
+    bridge: BridgeResult;
+    clusterCount: number;
+    distilled: DistillResult;
+    /**
+     * True when the verdict fetch returned exactly `limit` rows — a truncation
+     * signal. Under group retention (#1478) a truncated fetch means attempt groups
+     * may be PARTIAL (the source pages by enrichment order, not by instance), so
+     * `groupSize`/`nPass`/`nFail` understate the real group. The CLI surfaces this.
+     */
+    verdictsTruncated: boolean;
+    /** Stage-2 result — present only when `meta` was enabled. */
+    metaDistilled?: MetaDistillResult;
+}
+export interface PreparedDistillationEvidence {
+    bridge: BridgeResult;
+    collected: Array<{
+        ref: string;
+        instanceId: string;
+        env: TraceEnvelopeV0;
+    }>;
+    clusters: DistillCluster[];
+    verdictsTruncated: boolean;
+}
+export declare function prepareDistillationEvidence(deps: Pick<PipelineDeps, 'verdictSource' | 'fetchEvidence' | 'publishDeps' | 'anchorMode' | 'measurePerRecordControl' | 'slate' | 'groupCap' | 'limit' | 'now'>): Promise<PreparedDistillationEvidence>;
+export declare function runDistillationPipeline(deps: PipelineDeps): Promise<PipelineResult>;

package/dist/pipeline.js

@@ -0,0 +1,124 @@
+/**
+ * Distillation pipeline orchestrator (spec/2026-07-06-distillation-v1.md §6–§8).
+ *
+ * Composes the run-time loop end to end: verdict source → **bridge** (ledger →
+ * layer-1 evidence, both polarities, exclusion + dedup) → **gate + cluster**
+ * (eligible evidence grouped by distinct instance/tier) → **distill** (patterns
+ * + lessons → layer-2 skills). Every I/O boundary is an injected port, so the
+ * whole loop runs green under stubs (the Tier-0 dry-run) and swaps to the real
+ * adapters (verdict-source / fetchEvidence / claude distiller / publishSkill) +
+ * `ANTHROPIC_API_KEY` for a Tier-1 run with no code change.
+ *
+ * The bridge and distiller are decoupled in production through the corpus; here
+ * the pipeline captures each bridged envelope via the `publishEvidence` port and
+ * hands the same envelopes to clustering, so it reuses the tested `bridgeAttempts`
+ * (exclusion/dedup) without a corpus round-trip or a double fetch.
+ */
+import { buildBridgeManifestPublisher, bridgeAttempts, } from './bridge.js';
+import { capture } from './capture.js';
+import { publish, } from './publish.js';
+import { buildLayer2ScrubPipeline } from '@jinn-network/core/scrub';
+import { parseTraceEnvelopeV0 } from './envelope.js';
+import { clusterEvidence, buildMetaClusters } from './cluster.js';
+import { distillClusters, metaDistill } from './distill.js';
+export async function prepareDistillationEvidence(deps) {
+    const layer2 = buildLayer2ScrubPipeline();
+    const slateIds = deps.slate.instanceIds;
+    const collected = [];
+    // The bridge's publish port: capture at layer-2 altitude, publish layer-1
+    // evidence, and collect the envelope for the gate/cluster stage.
+    const publishEvidence = async (task, ref) => {
+        const pending = await capture(task, { pipeline: layer2 });
+        const env = parseTraceEnvelopeV0({
+            ...pending.draft,
+            consent: { contributionConsent: true, scrubCompleted: true },
+        });
+        const published = await publish(pending, deps.publishDeps);
+        if (published.vetoed)
+            throw new Error('unexpected veto bridging evidence');
+        collected.push({ ref: published.envelopeRef, instanceId: ref.instanceId, env });
+        return { envelopeRef: published.envelopeRef, anchorTx: published.anchorTx };
+    };
+    let publishManifestBatch;
+    if (deps.anchorMode === 'manifest') {
+        if (!('publishManifestBody' in deps.publishDeps) ||
+            !('anchorManifest' in deps.publishDeps) ||
+            !('recordManifestAnchor' in deps.publishDeps)) {
+            throw new Error('manifest anchor mode requires manifest-capable publish deps');
+        }
+        const manifestDeps = deps.publishDeps;
+        const publisher = buildBridgeManifestPublisher(manifestDeps, {
+            pipeline: layer2,
+            ...(deps.measurePerRecordControl ? { measurePerRecordControl: true } : {}),
+        });
+        publishManifestBatch = async (candidates) => {
+            const result = await publisher(candidates);
+            if (result.publishedMembers.length !== result.memberRefs.length) {
+                throw new Error(`manifest publisher returned ${result.publishedMembers.length} envelopes for ${result.memberRefs.length} refs`);
+            }
+            for (let index = 0; index < result.publishedMembers.length; index += 1) {
+                const member = result.publishedMembers[index];
+                const candidate = candidates[index];
+                collected.push({
+                    ref: result.memberRefs[index],
+                    instanceId: candidate.ref.instanceId,
+                    env: member.trace,
+                });
+            }
+            return result;
+        };
+    }
+    // 1. Bridge — ledger → layer-1 evidence (exclusion + dedup live in bridgeAttempts).
+    const refs = await deps.verdictSource.list({ ...(deps.limit !== undefined ? { limit: deps.limit } : {}) });
+    const verdictsTruncated = deps.limit !== undefined && refs.length >= deps.limit;
+    const bridge = await bridgeAttempts(refs, {
+        slateInstanceIds: slateIds,
+        fetchEvidence: deps.fetchEvidence,
+        publishEvidence,
+        anchorMode: deps.anchorMode ?? 'per-record',
+        ...(publishManifestBatch ? { publishManifestBatch } : {}),
+        groupCap: deps.groupCap ?? 8,
+        ...(deps.now ? { now: deps.now } : {}),
+    });
+    // 2. Gate + cluster — eligible evidence grouped by distinct (instance, tier).
+    //    heldOut is defence-in-depth over the bridge's own exclusion.
+    const clusters = clusterEvidence(collected, { heldOut: (id) => slateIds.has(id) });
+    return { bridge, collected, clusters, verdictsTruncated };
+}
+export async function runDistillationPipeline(deps) {
+    const prepared = await prepareDistillationEvidence(deps);
+    const { bridge, clusters, verdictsTruncated } = prepared;
+    // 3. Distill — patterns + lessons → layer-2 skills (output scrub + contamination scan inside).
+    const distilled = await distillClusters(clusters, {
+        distill: deps.distill,
+        publishSkill: deps.publishSkill,
+        slate: deps.slate,
+        ...(deps.distribution ? { distribution: deps.distribution } : {}),
+        ...(deps.distillModel ? { distillModel: deps.distillModel } : {}),
+        ...(deps.now ? { now: deps.now } : {}),
+    });
+    // 4. Stage-2 (opt-in) — cross-instance meta-distill over the stage-1 skills
+    //    this run just published. Reads only in-memory results (no corpus round-trip).
+    let metaDistilled;
+    if (deps.meta) {
+        if (!deps.metaDistill) {
+            throw new Error('runDistillationPipeline: meta is enabled but no metaDistill port was provided');
+        }
+        const clusterById = new Map(clusters.map((c) => [c.clusterId, c]));
+        const stage1 = distilled.published.map((p) => {
+            const cl = clusterById.get(p.clusterId);
+            if (!cl)
+                throw new Error(`meta: no originating cluster for ${p.clusterId}`);
+            return { clusterId: p.clusterId, skillKind: p.skillKind, pkg: p.pkg, evidenceRefs: cl.evidenceRefs, instanceIds: cl.instanceIds };
+        });
+        metaDistilled = await metaDistill(buildMetaClusters(stage1), {
+            metaDistill: deps.metaDistill,
+            publishSkill: deps.publishSkill,
+            slate: deps.slate,
+            ...(deps.distribution ? { distribution: deps.distribution } : {}),
+            ...(deps.distillModel ? { distillModel: deps.distillModel } : {}),
+            ...(deps.now ? { now: deps.now } : {}),
+        });
+    }
+    return { bridge, clusterCount: clusters.length, distilled, verdictsTruncated, ...(metaDistilled ? { metaDistilled } : {}) };
+}

package/dist/plugin-wiring.d.ts

@@ -0,0 +1,4 @@
+import { type JinnPlugin, type JinnPluginDeps } from '@jinn-network/plugin';
+/** Assemble the real port set used by versioned process hosts. */
+export declare function buildPluginDepsFromEnv(overrides?: Partial<JinnPluginDeps>): JinnPluginDeps;
+export declare function buildPluginFromEnv(overrides?: Partial<JinnPluginDeps>): JinnPlugin;

package/dist/plugin-wiring.js

@@ -0,0 +1,54 @@
+import { createJinnPlugin } from '@jinn-network/plugin';
+import { createContributionAdapter, createCorpusAdapter, createEvidenceAdapter, createLocalLearningAdapter, createSkillsAdapter, } from './adapters/index.js';
+import { ContributionStore, defaultEvidenceIndexPath, reindexEvidenceStore, resolveContributionStateDir, } from '@jinn-network/core';
+import { DEFAULT_EPISODES_DIR, DEFAULT_SKILLS_INSTALL_DIR, localSkillProvenance, stagingDirFor, } from './distill-captures.js';
+import { buildDefaultLayer } from './layer-default.js';
+function episodesDir() {
+    return process.env['JINN_LAYER_EPISODES_DIR'] ?? DEFAULT_EPISODES_DIR;
+}
+function skillsInstallDir() {
+    return process.env['JINN_LAYER_SKILLS_INSTALL_DIR'] ?? DEFAULT_SKILLS_INSTALL_DIR;
+}
+/** Assemble the real port set used by versioned process hosts. */
+export function buildPluginDepsFromEnv(overrides = {}) {
+    const corpus = overrides.corpus ?? createCorpusAdapter({ layer: buildDefaultLayer() });
+    const evidenceDir = episodesDir();
+    const evidenceIndexPath = process.env['JINN_LAYER_EVIDENCE_INDEX_PATH']
+        ?? defaultEvidenceIndexPath(evidenceDir);
+    let refreshIndex = Promise.resolve();
+    const evidence = overrides.evidence ?? createEvidenceAdapter({
+        capturesDir: evidenceDir,
+        onStoreChanged: () => {
+            const refresh = () => {
+                const report = reindexEvidenceStore({
+                    episodesDir: evidenceDir,
+                    indexPath: evidenceIndexPath,
+                });
+                if (!report.indexUpdated) {
+                    throw new Error(report.indexError ?? 'derived evidence index was not updated');
+                }
+            };
+            refreshIndex = refreshIndex.then(refresh, refresh);
+            return refreshIndex;
+        },
+    });
+    const contribution = overrides.contribution ?? createContributionAdapter({
+        statusStore: new ContributionStore({ stateDir: resolveContributionStateDir() }),
+        evidence,
+    });
+    const skills = overrides.skills ?? createSkillsAdapter({ installDir: skillsInstallDir() });
+    const localLearning = overrides.localLearning ?? createLocalLearningAdapter({
+        distiller: {
+            distill: async () => ({
+                clusterCount: 0,
+                distilled: { published: [], rejected: [], errors: [] },
+            }),
+        },
+        loadCaptures: async () => [],
+        listSkills: async () => localSkillProvenance(skillsInstallDir(), stagingDirFor(skillsInstallDir())),
+    });
+    return { corpus, evidence, contribution, localLearning, skills };
+}
+export function buildPluginFromEnv(overrides = {}) {
+    return createJinnPlugin(buildPluginDepsFromEnv(overrides));
+}

package/dist/preview.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Harness-layer scrub preview — "see exactly what would leave your machine".
+ *
+ * `preview(pending)` renders a `PendingEnvelope` as a `ScrubReport`: the
+ * canonical EpisodeV1 payload exactly as it would publish, plus the redaction
+ * diff. Consent is the publish action; it is not duplicated inside the shared
+ * local/public evidence payload.
+ *
+ * `redactions[].before` values are the original (sensitive) content: local
+ * display only, NEVER persisted — anything that serialises a report for
+ * storage or transport must strip them (`stripBeforeValues`).
+ *
+ * Plan: docs/superpowers/plans/2026-07-02-jinn-harness-network-v0-plan.md
+ * Task 3 (issue #1310).
+ */
+import type { EpisodeV1Write } from '@jinn-network/plugin';
+import type { PendingEnvelope, ScrubRedaction } from './capture.js';
+export interface ScrubReport {
+    /** The envelope exactly as it would publish (consent flags asserted). */
+    envelope: EpisodeV1Write;
+    /** The redaction diff. `before` is local-display-only, never persisted. */
+    redactions: ScrubRedaction[];
+}
+/** Render the pending envelope's scrub report. Pure and local — no I/O. */
+export declare function preview(pending: PendingEnvelope): ScrubReport;
+/**
+ * The persistence-safe projection of a redaction list: identical minus every
+ * `before` value. Use this for ANY serialised output (e.g. `--json`) — the
+ * originals exist for the operator's eyes on their own terminal, nothing else.
+ */
+export declare function stripBeforeValues(redactions: ScrubRedaction[]): Array<Omit<ScrubRedaction, 'before'>>;

package/dist/preview.js

@@ -0,0 +1,28 @@
+/**
+ * Harness-layer scrub preview — "see exactly what would leave your machine".
+ *
+ * `preview(pending)` renders a `PendingEnvelope` as a `ScrubReport`: the
+ * canonical EpisodeV1 payload exactly as it would publish, plus the redaction
+ * diff. Consent is the publish action; it is not duplicated inside the shared
+ * local/public evidence payload.
+ *
+ * `redactions[].before` values are the original (sensitive) content: local
+ * display only, NEVER persisted — anything that serialises a report for
+ * storage or transport must strip them (`stripBeforeValues`).
+ *
+ * Plan: docs/superpowers/plans/2026-07-02-jinn-harness-network-v0-plan.md
+ * Task 3 (issue #1310).
+ */
+import { toPublishedEpisode } from './publish.js';
+/** Render the pending envelope's scrub report. Pure and local — no I/O. */
+export function preview(pending) {
+    return { envelope: toPublishedEpisode(pending), redactions: pending.redactions };
+}
+/**
+ * The persistence-safe projection of a redaction list: identical minus every
+ * `before` value. Use this for ANY serialised output (e.g. `--json`) — the
+ * originals exist for the operator's eyes on their own terminal, nothing else.
+ */
+export function stripBeforeValues(redactions) {
+    return redactions.map(({ before: _before, ...rest }) => rest);
+}

package/dist/process-contract.d.ts

@@ -0,0 +1,303 @@
+import { z } from 'zod';
+import { type FirstTurnPickupResult, type ContributionLedgerEntry, type JinnPluginDeps, type SessionEndResult } from '@jinn-network/plugin';
+export declare const PROCESS_CONTRACT_VERSION: 1;
+export declare const PROCESS_STATUSES: readonly ["ok", "degraded", "unavailable"];
+export type ProcessStatus = (typeof PROCESS_STATUSES)[number];
+export interface ProcessEnvelope<T> {
+    contractVersion: typeof PROCESS_CONTRACT_VERSION;
+    status: ProcessStatus;
+    value?: T;
+    reason?: string;
+}
+export declare const SessionPickupRequestV1Schema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<1>;
+    meta: z.ZodObject<{
+        sessionId: z.ZodString;
+        taskSummary: z.ZodString;
+        distributionTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        harness: z.ZodObject<{
+            name: z.ZodString;
+            version: z.ZodString;
+        }, z.core.$strict>;
+        model: z.ZodString;
+        tools: z.ZodArray<z.ZodString>;
+        skillsLoadout: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        pickup: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodBoolean>;
+            autoAdopt: z.ZodDefault<z.ZodBoolean>;
+            autoAdoptTier: z.ZodDefault<z.ZodEnum<{
+                "user-accepted": "user-accepted";
+                "tests-passed": "tests-passed";
+                "evaluator-verified": "evaluator-verified";
+            }>>;
+            maxCandidates: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strict>>;
+        repositorySlug: z.ZodOptional<z.ZodString>;
+        kind: z.ZodOptional<z.ZodEnum<{
+            user: "user";
+            "host-internal": "host-internal";
+        }>>;
+        parentSessionId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>;
+    firstMessage: z.ZodString;
+}, z.core.$strict>;
+export declare const SessionEndRequestV1Schema: z.ZodObject<{
+    contractVersion: z.ZodLiteral<1>;
+    episode: z.ZodObject<{
+        schemaVersion: z.ZodLiteral<"jinn.episode.v1">;
+        episodeId: z.ZodString;
+        retrievalVisible: z.ZodDefault<z.ZodBoolean>;
+        session: z.ZodObject<{
+            sessionId: z.ZodString;
+            capturedAt: z.ZodISODateTime;
+            kind: z.ZodEnum<{
+                user: "user";
+                "host-internal": "host-internal";
+            }>;
+            parentSessionId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        origin: z.ZodObject<{
+            writer: z.ZodString;
+            build: z.ZodString;
+        }, z.core.$strict>;
+        task: z.ZodObject<{
+            summary: z.ZodString;
+            distributionTags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            repositorySlug: z.ZodOptional<z.ZodString>;
+            baseCommit: z.ZodOptional<z.ZodString>;
+            createdAt: z.ZodOptional<z.ZodNumber>;
+            instanceId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        trajectory: z.ZodArray<z.ZodObject<{
+            spanId: z.ZodString;
+            parentSpanId: z.ZodNullable<z.ZodString>;
+            kind: z.ZodEnum<{
+                "jinn.agent_turn": "jinn.agent_turn";
+                "jinn.tool_call": "jinn.tool_call";
+            }>;
+            name: z.ZodString;
+            startTimeUnixNano: z.ZodString;
+            endTimeUnixNano: z.ZodString;
+            attributes: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            redactedKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            truncatedKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            events: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                timeUnixNano: z.ZodString;
+                name: z.ZodString;
+                attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strict>>>;
+            status: z.ZodOptional<z.ZodObject<{
+                code: z.ZodEnum<{
+                    UNSET: "UNSET";
+                    OK: "OK";
+                    ERROR: "ERROR";
+                }>;
+                message: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        environment: z.ZodObject<{
+            harness: z.ZodObject<{
+                name: z.ZodString;
+                version: z.ZodString;
+            }, z.core.$strict>;
+            model: z.ZodString;
+            tools: z.ZodArray<z.ZodString>;
+            skillsLoadout: z.ZodArray<z.ZodString>;
+            generatorModel: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                provider: z.ZodOptional<z.ZodString>;
+                openWeights: z.ZodOptional<z.ZodBoolean>;
+                source: z.ZodEnum<{
+                    stream: "stream";
+                    config: "config";
+                }>;
+            }, z.core.$strict>>;
+            distributionClass: z.ZodOptional<z.ZodEnum<{
+                unknown: "unknown";
+                open: "open";
+                "restricted-tos": "restricted-tos";
+            }>>;
+            verifier: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"f2p-p2p">;
+                failToPass: z.ZodArray<z.ZodString>;
+                passToPass: z.ZodArray<z.ZodString>;
+                evalSemanticsVersion: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                type: z.ZodEnum<{
+                    command: "command";
+                    none: "none";
+                }>;
+                failToPass: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                passToPass: z.ZodDefault<z.ZodArray<z.ZodString>>;
+                evalSemanticsVersion: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>], "type">>;
+        }, z.core.$strict>;
+        outcome: z.ZodPreprocess<z.ZodObject<{
+            status: z.ZodEnum<{
+                completed: "completed";
+                failed: "failed";
+                abandoned: "abandoned";
+            }>;
+            verificationStrength: z.ZodEnum<{
+                "user-accepted": "user-accepted";
+                "tests-passed": "tests-passed";
+                "evaluator-verified": "evaluator-verified";
+            }>;
+            summary: z.ZodOptional<z.ZodString>;
+            acceptedDiff: z.ZodOptional<z.ZodBoolean>;
+            testRuns: z.ZodOptional<z.ZodObject<{
+                passed: z.ZodNumber;
+                failed: z.ZodNumber;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+        cost: z.ZodObject<{
+            durationMs: z.ZodNumber;
+            tokens: z.ZodOptional<z.ZodObject<{
+                input: z.ZodNumber;
+                output: z.ZodNumber;
+            }, z.core.$strict>>;
+            usdEstimate: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        retention: z.ZodObject<{
+            policy: z.ZodEnum<{
+                "local-private": "local-private";
+                "contribution-eligible": "contribution-eligible";
+            }>;
+        }, z.core.$strict>;
+        provenance: z.ZodDefault<z.ZodEnum<{
+            contributed: "contributed";
+            imported: "imported";
+            "derived-from-history": "derived-from-history";
+        }>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            episodeId: z.ZodString;
+            mintRef: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+        attemptGroup: z.ZodOptional<z.ZodObject<{
+            groupId: z.ZodString;
+            attemptId: z.ZodString;
+            relatedAttemptRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            groupSize: z.ZodOptional<z.ZodNumber>;
+            nPass: z.ZodOptional<z.ZodNumber>;
+            nFail: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>>;
+        activity: z.ZodOptional<z.ZodObject<{
+            retrievalFired: z.ZodBoolean;
+            eligibleRefs: z.ZodArray<z.ZodString>;
+            deliveredRefs: z.ZodArray<z.ZodString>;
+            deliveryMode: z.ZodEnum<{
+                degraded: "degraded";
+                disabled: "disabled";
+                delivered: "delivered";
+                withheld: "withheld";
+            }>;
+            deliveredContentHash: z.ZodOptional<z.ZodString>;
+            searchedTerms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            providedRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            surfacedRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            fetchedRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+            installedSkillRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        }, z.core.$strict>>;
+        eligibility: z.ZodOptional<z.ZodObject<{
+            eligible: z.ZodBoolean;
+            reason: z.ZodString;
+            checkedAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        contributionCandidate: z.ZodOptional<z.ZodObject<{
+            testRuns: z.ZodArray<z.ZodObject<{
+                command: z.ZodString;
+                exitCode: z.ZodNumber;
+                at: z.ZodISODateTime;
+            }, z.core.$strict>>;
+            skillEvents: z.ZodArray<z.ZodObject<{
+                skillRef: z.ZodString;
+                action: z.ZodEnum<{
+                    loaded: "loaded";
+                    invoked: "invoked";
+                }>;
+            }, z.core.$strict>>;
+            schemaVersion: z.ZodLiteral<"jinn.contribution-candidate.v1">;
+            sourceId: z.ZodString;
+            repositorySlug: z.ZodString;
+            baseCommit: z.ZodString;
+            acceptedDiff: z.ZodString;
+            intermediateFailureDiffs: z.ZodArray<z.ZodString>;
+            publishMinedTasksConsent: z.ZodBoolean;
+            createdAt: z.ZodISODateTime;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    activity: z.ZodObject<{
+        retrievalFired: z.ZodBoolean;
+        eligibleRefs: z.ZodArray<z.ZodString>;
+        deliveredRefs: z.ZodArray<z.ZodString>;
+        deliveryMode: z.ZodEnum<{
+            degraded: "degraded";
+            disabled: "disabled";
+            delivered: "delivered";
+            withheld: "withheld";
+        }>;
+        deliveredContentHash: z.ZodOptional<z.ZodString>;
+        searchedTerms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        providedRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        surfacedRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        fetchedRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        installedSkillRefs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strict>;
+    eligibilityInputs: z.ZodObject<{
+        publicRepo: z.ZodOptional<z.ZodBoolean>;
+        acceptedDiff: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strict>;
+    contributionCandidate: z.ZodOptional<z.ZodObject<{
+        testRuns: z.ZodArray<z.ZodObject<{
+            command: z.ZodString;
+            exitCode: z.ZodNumber;
+            at: z.ZodISODateTime;
+        }, z.core.$strict>>;
+        skillEvents: z.ZodArray<z.ZodObject<{
+            skillRef: z.ZodString;
+            action: z.ZodEnum<{
+                loaded: "loaded";
+                invoked: "invoked";
+            }>;
+        }, z.core.$strict>>;
+        schemaVersion: z.ZodLiteral<"jinn.contribution-candidate.v1">;
+        sourceId: z.ZodString;
+        repositorySlug: z.ZodString;
+        baseCommit: z.ZodString;
+        acceptedDiff: z.ZodString;
+        intermediateFailureDiffs: z.ZodArray<z.ZodString>;
+        publishMinedTasksConsent: z.ZodBoolean;
+        createdAt: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    contributionVetoed: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+export type SessionPickupRequestV1 = z.infer<typeof SessionPickupRequestV1Schema>;
+export type SessionEndRequestV1 = z.infer<typeof SessionEndRequestV1Schema>;
+export declare function envelope<T>(status: ProcessStatus, value?: T, reason?: string): ProcessEnvelope<T>;
+export declare function sessionEndEnvelope(result: SessionEndResult): ProcessEnvelope<SessionEndResult>;
+/** Track pickup port health without repeating requests merely to classify output. */
+export declare function trackingCorpus(deps: JinnPluginDeps): {
+    deps: JinnPluginDeps;
+    status: () => ProcessStatus;
+    reason: () => string | undefined;
+};
+export type SessionPickupEnvelope = ProcessEnvelope<FirstTurnPickupResult>;
+/**
+ * Preserve useful pickup evidence when one candidate-local corpus read is
+ * unavailable. A wholly unavailable corpus with no packets remains
+ * `unavailable`; partial success is `degraded` so hosts still consume the
+ * returned packets. Core-caught promise rejections also surface through the
+ * result's degraded reason even when the tracking wrapper observed no
+ * PortResult.
+ */
+export declare function sessionPickupEnvelope(result: FirstTurnPickupResult, observedStatus: ProcessStatus, observedReason?: string): SessionPickupEnvelope;
+export interface ContributionLedgerRowV1 {
+    time: string | null;
+    task: string;
+    env: string | null;
+    anchor: string | null;
+    tier: 'user-accepted' | 'tests-passed' | null;
+    state: ContributionLedgerEntry['status'];
+}
+/** Persistence-safe terminal projection. Local IDs and candidate evidence do not cross it. */
+export declare function contributionLedgerRow(entry: ContributionLedgerEntry): ContributionLedgerRowV1;