@jinn-network/jinn-layer 0.1.0

package/dist/execution-publish.d.ts

@@ -0,0 +1,62 @@
+import { type Artifact, type SignedEnvelope, type UnsignedEnvelope } from '@jinn-network/core';
+export interface CapturePublishedBlob {
+    cid: string;
+    sha256?: string;
+    endpoint?: string;
+    priceUsdc?: string;
+}
+export interface CaptureEnvelopeAnchorInput {
+    metadataKey: string;
+    envelopeCid: string;
+    envelopeHash: `0x${string}`;
+    envelope: SignedEnvelope;
+    requireSuccessfulReceipt?: boolean;
+    onBroadcast?: (txHash: `0x${string}`) => void;
+    onPrepared?: (payloadHex: `0x${string}`) => void;
+}
+export interface CaptureEnvelopeAnchorResult {
+    txHash?: `0x${string}`;
+    blockNumber?: number | null;
+    gasUsed?: bigint | null;
+    feeWei?: bigint | null;
+    payloadHex?: `0x${string}`;
+}
+/**
+ * The capture-row facts the layer needs to wrap an episode or skill. This is
+ * deliberately narrower than the daemon's persistence row.
+ */
+export interface LayerCaptureRow {
+    sessionId: string;
+    capturedAt: string;
+    originatingTool: {
+        name: string;
+        version?: string;
+    };
+    capturePath: string;
+    spanCount: number;
+    redactedSpanCount: number;
+    durationMs: number;
+    repoRemoteUrl?: string | null;
+    repoCommitHash?: string | null;
+}
+export interface BuildUnsignedCaptureEnvelopeArgs {
+    capture: LayerCaptureRow;
+    now: Date;
+    participant: {
+        safeAddress: `0x${string}`;
+        agentEoa: `0x${string}`;
+    };
+    signerAddress: `0x${string}`;
+    clientGitSha: string;
+    artifacts: Artifact[];
+    harnessBundleSha: string;
+    executorOverrides?: Partial<UnsignedEnvelope['executor']>;
+    solverType?: string;
+    role?: UnsignedEnvelope['role'];
+}
+/**
+ * Build the byte-compatible `jinn.execution.v1` wrapper previously supplied
+ * by the client capture publisher.
+ */
+export declare function buildUnsignedCaptureEnvelope(args: BuildUnsignedCaptureEnvelopeArgs): UnsignedEnvelope;
+export declare function sha256Hex(input: string | Uint8Array): string;

package/dist/execution-publish.js

@@ -0,0 +1,72 @@
+import { createHash } from 'node:crypto';
+import { UnsignedEnvelopeSchema, canonicalJson, } from '@jinn-network/core';
+/**
+ * Build the byte-compatible `jinn.execution.v1` wrapper previously supplied
+ * by the client capture publisher.
+ */
+export function buildUnsignedCaptureEnvelope(args) {
+    const { capture, now, participant, signerAddress, artifacts, harnessBundleSha, } = args;
+    const sessionProvenance = {
+        sessionId: capture.sessionId,
+        capturedAt: capture.capturedAt,
+        originatingTool: capture.originatingTool,
+        ...(capture.repoRemoteUrl || capture.repoCommitHash
+            ? {
+                repo: {
+                    ...(capture.repoRemoteUrl
+                        ? { remoteUrl: capture.repoRemoteUrl }
+                        : {}),
+                    ...(capture.repoCommitHash
+                        ? { commitHash: capture.repoCommitHash }
+                        : {}),
+                },
+            }
+            : {}),
+        license: { operatorAssertion: 'unspecified' },
+    };
+    const windowEnd = Math.floor(now.getTime() / 1000);
+    const runtimeBundleDigest = `sha256:${sha256Hex(canonicalJson({
+        tool: capture.originatingTool,
+        capturePath: capture.capturePath,
+    }))}`;
+    const executor = {
+        implName: capture.originatingTool.name,
+        implVersion: capture.originatingTool.version ?? 'unknown',
+        clientGitSha: args.clientGitSha,
+        codeDigest: `sha256:${harnessBundleSha}`,
+        runtimeBundleDigest,
+        plugins: [],
+        signingKey: { kind: 'agent-eoa', pubkey: signerAddress },
+        mode: 'train',
+        ...args.executorOverrides,
+    };
+    return UnsignedEnvelopeSchema.parse({
+        schemaVersion: 'jinn.execution.v1',
+        solverType: args.solverType ?? 'capture',
+        role: args.role ?? 'capture',
+        generatedAt: windowEnd,
+        sessionProvenance,
+        participant,
+        window: {
+            startTs: Math.max(0, windowEnd - Math.ceil(capture.durationMs / 1000)),
+            endTs: windowEnd,
+        },
+        executor,
+        evidenceTier: 'self-signed',
+        attestation: null,
+        trajectory: null,
+        artifacts,
+        payload: {
+            capture: {
+                sessionId: capture.sessionId,
+                capturePath: capture.capturePath,
+                spanCount: capture.spanCount,
+                redactedSpanCount: capture.redactedSpanCount,
+                durationMs: capture.durationMs,
+            },
+        },
+    });
+}
+export function sha256Hex(input) {
+    return createHash('sha256').update(input).digest('hex');
+}

package/dist/gate.d.ts

@@ -0,0 +1,39 @@
+/**
+ * The promotion gate — which layer-1 evidence is eligible to distill
+ * (spec/2026-07-06-distillation-v1.md §6, D3/D10).
+ *
+ * Tiered eligibility: a `completed` + `evaluator-verified` trace is
+ * **pattern-eligible** (→ strategic pattern); a `failed` + `evaluator-verified`
+ * trace is **lesson-eligible** (→ failure lesson). Both require
+ * raw-evidence provenance (contributed or derived), not-held-out, and a
+ * passing redaction-health check. Noise (`INVALID`/`INDETERMINATE`/
+ * `abandoned`, `user-accepted` failures) is not distillable — the bridge (§8)
+ * already drops non-definitive verdicts, and this gate is the second,
+ * evidence-level guard.
+ *
+ * The redaction-health guard (the #1409 defence, corrected per the adversarial
+ * review): measure **intra-value placeholder density** (placeholder chars ÷
+ * content chars) over the **union of every stage's placeholder shape**, and only
+ * on values long enough for shredding to be the harm — a short fully-redacted
+ * value is a legitimate single-secret redaction, not prose-mangling.
+ */
+import type { TraceEnvelopeV0 } from './envelope.js';
+export type EligibilityTier = 'pattern' | 'lesson';
+export interface RedactionHealth {
+    /** True when some long content value is mostly placeholder tokens. */
+    defaced: boolean;
+    /** The worst intra-value placeholder density seen (over length-qualifying values). */
+    maxValueDensity: number;
+}
+export interface EligibilityResult {
+    eligible: boolean;
+    tier: EligibilityTier | null;
+    reasons: string[];
+    redactionHealth: RedactionHealth;
+}
+export declare function redactionHealth(env: TraceEnvelopeV0, maxDensity?: number): RedactionHealth;
+export declare function evaluateEligibility(env: TraceEnvelopeV0, opts?: {
+    heldOut?: boolean;
+    maxPlaceholderDensity?: number;
+    acceptUserAccepted?: boolean;
+}): EligibilityResult;

package/dist/gate.js

@@ -0,0 +1,106 @@
+/**
+ * The promotion gate — which layer-1 evidence is eligible to distill
+ * (spec/2026-07-06-distillation-v1.md §6, D3/D10).
+ *
+ * Tiered eligibility: a `completed` + `evaluator-verified` trace is
+ * **pattern-eligible** (→ strategic pattern); a `failed` + `evaluator-verified`
+ * trace is **lesson-eligible** (→ failure lesson). Both require
+ * raw-evidence provenance (contributed or derived), not-held-out, and a
+ * passing redaction-health check. Noise (`INVALID`/`INDETERMINATE`/
+ * `abandoned`, `user-accepted` failures) is not distillable — the bridge (§8)
+ * already drops non-definitive verdicts, and this gate is the second,
+ * evidence-level guard.
+ *
+ * The redaction-health guard (the #1409 defence, corrected per the adversarial
+ * review): measure **intra-value placeholder density** (placeholder chars ÷
+ * content chars) over the **union of every stage's placeholder shape**, and only
+ * on values long enough for shredding to be the harm — a short fully-redacted
+ * value is a legitimate single-secret redaction, not prose-mangling.
+ */
+/**
+ * Union of the placeholder shapes the layer-1 pipeline emits (§6, §10).
+ * Module-level `const` with the `g` flag: safe here because `String.match`
+ * (used below, not `RegExp.exec` in a loop) ignores/resets `lastIndex` on each
+ * call — do not switch to `.exec()` without resetting `lastIndex`.
+ */
+const PLACEHOLDER_RE = /\[SECRET:[^\]]*\]|\[PII:[^\]]*\]|\[EMAIL\]|\[[A-Z]+_\d+\]/g;
+/** Below this length a fully-redacted value is a legit single-secret redaction, not shredding. */
+const MIN_CONTENT_LEN = 64;
+const DEFAULT_MAX_DENSITY = 0.4;
+/**
+ * Content-bearing string values to check for defacement: every step attribute
+ * PLUS the scrubbed prose surfaces `task.summary` and `outcome.summary`. The
+ * summaries are exactly the fields the distiller reads first (§7) and the ones
+ * #1409 defaced, so guarding only step attributes would leave the module's main
+ * target uncovered.
+ *
+ * NOTE (v1 scope): only TOP-LEVEL string values are measured. `attributes` is
+ * `z.record(z.unknown())`, so a value may be a nested object/array — those are
+ * skipped. v1 bridged evidence carries flat string attributes (a patch, a
+ * verdict), so this is sufficient today; recursing into nested values is a
+ * follow-up if a harness ever emits structured attributes.
+ *
+ * NOTE (deliberate deviation from §6): §6 prefers driving the guard off the
+ * recorded redaction receipt (`redactedKeys`/`truncatedKeys`). We instead scan
+ * the union of placeholder SHAPES across all content-bearing values, because
+ * `task.summary`/`outcome.summary` have no per-key receipt and a uniform scan
+ * covers them. The trade-off is brittleness: a NEW placeholder shape must be
+ * added to PLACEHOLDER_RE or it is invisible to the density metric.
+ */
+function contentBearingValues(env) {
+    const out = [];
+    for (const step of env.steps) {
+        for (const value of Object.values(step.attributes)) {
+            if (typeof value === 'string')
+                out.push(value);
+        }
+    }
+    if (typeof env.task.summary === 'string')
+        out.push(env.task.summary);
+    if (typeof env.outcome.summary === 'string')
+        out.push(env.outcome.summary);
+    return out;
+}
+export function redactionHealth(env, maxDensity = DEFAULT_MAX_DENSITY) {
+    let worst = 0;
+    for (const value of contentBearingValues(env)) {
+        if (value.length < MIN_CONTENT_LEN)
+            continue;
+        const placeholderChars = (value.match(PLACEHOLDER_RE) ?? []).reduce((n, m) => n + m.length, 0);
+        const density = placeholderChars / value.length;
+        if (density > worst)
+            worst = density;
+    }
+    return { defaced: worst > maxDensity, maxValueDensity: worst };
+}
+export function evaluateEligibility(env, opts = {}) {
+    const maxDensity = opts.maxPlaceholderDensity ?? DEFAULT_MAX_DENSITY;
+    const reasons = [];
+    const rh = redactionHealth(env, maxDensity);
+    if (env.provenance === 'imported') {
+        reasons.push('imported seeds are already-distilled layer-2, not raw evidence');
+    }
+    if (opts.heldOut) {
+        reasons.push('in the held-out cap-v0 slate');
+    }
+    if (rh.defaced) {
+        reasons.push(`defaced: placeholder density ${rh.maxValueDensity.toFixed(2)} exceeds ${maxDensity}`);
+    }
+    let tier = null;
+    const evaluatorVerified = env.outcome.verifiabilityTier === 'evaluator-verified';
+    const userAccepted = opts.acceptUserAccepted === true && env.outcome.verifiabilityTier === 'user-accepted';
+    const acceptedTier = evaluatorVerified || userAccepted;
+    if (env.outcome.status === 'completed' && acceptedTier) {
+        tier = 'pattern';
+    }
+    else if (env.outcome.status === 'failed' && acceptedTier) {
+        tier = 'lesson';
+    }
+    else {
+        reasons.push(`outcome not distillable (status=${env.outcome.status}, tier=${env.outcome.verifiabilityTier}; ` +
+            `need ${opts.acceptUserAccepted ? 'evaluator-verified or user-accepted' : 'evaluator-verified'} ` +
+            'completed→pattern or failed→lesson)');
+    }
+    const eligible = reasons.length === 0 && tier !== null;
+    return { eligible, tier: eligible ? tier : null, reasons, redactionHealth: rh };
+}

package/dist/index.d.ts

@@ -0,0 +1,49 @@
+/**
+ * @jinn-network/jinn-layer — standalone plugin process and embeddable layer.
+ *
+ * v0 exposes the corpus consume path (search/get), the frozen layer-1 trace
+ * envelope read-compat schema, the capture path (scrub + preview), and the publish path
+ * (consent conversion + anchor + contribution ledger).
+ */
+export { createHarnessLayer, DEFAULT_IPFS_GATEWAY_URL, type HarnessLayer, type HarnessLayerConfig, type ResolvedHarnessLayerConfig, type CorpusSearchHit, type CorpusRecord, type CorpusArtifact, } from './consume.js';
+export { corpusProbes, enoughCorpusForRepo, CORPUS_ONBOARDING_K, type DoctorCheck, } from './corpus-probes.js';
+export { capture, parseCapturedTask, CapturedTaskSchema, CaptureScrubError, PENDING_ENVELOPE_KIND, type CapturedTask, type CaptureOptions, type PendingEnvelope, type ScrubRedaction, } from './capture.js';
+export { preview, stripBeforeValues, type ScrubReport, } from './preview.js';
+export { computeSignal, type SignalInput, type SignalRow, type SignalOptions, } from './signal.js';
+export { publish, PublishLedgerError, toPublishedEpisode, toTraceEnvelope, EPISODE_ARTIFACT_TYPE, TRACE_ENVELOPE_ARTIFACT_TYPE, type HarnessPublishDeps, type PublishedResult, type PublishOptions, type PublishResult, } from './publish.js';
+export { extractSkill, type ExtractedSkill, } from './skill.js';
+export { SKILL_ARTIFACT_TYPE, SkillArtifactV1Schema, SkillProvenanceSchema, SkillCompanionFileSchema, MAX_SKILL_FILES, MAX_SKILL_TOTAL_DECODED_BYTES, type SkillArtifactV1, type SkillProvenance, type SkillCompanionFile, } from '@jinn-network/core';
+export { buildSkillMarkdown, parseSkillMarkdown, assertConformantName, SkillPackageMetaSchema, type SkillPackage, type SkillPackageMeta, } from './skill-package.js';
+export { publishSkill, toSkillArtifactV1, SKILL_SOLVER_TYPE, type SkillPublishDeps, type PublishSkillResult, type SkillLifecycle, } from './publish-skill.js';
+export { bridgeAttempts, toBridgeCapturedTask, repoFromInstanceId, buildBridgeEvidencePublisher, type AttemptRef, type BridgeEvidence, type BridgeDeps, type BridgeResult, } from './bridge.js';
+export { evaluateEligibility, redactionHealth, type EligibilityTier, type EligibilityResult, type RedactionHealth, } from './gate.js';
+export { distillClusters, lexicalContaminationScan, type DistillCluster, type DistillLLMOutput, type DistillDeps, type DistillResult, } from './distill.js';
+export { createLocalDistiller, createNetworkDistiller, createLocalSkillSink, NetworkDistillerNotWiredError, type Distiller, type DistillerResult, type LocalDistillerDeps, type SkillSink, type HeldOutSlate, } from './distiller.js';
+export { createClaudeDistiller, createClaudeMetaDistiller, createCodexDistiller, createCodexMetaDistiller, DEFAULT_MODEL as DEFAULT_CLAUDE_DISTILL_MODEL, DEFAULT_CODEX_MODEL, DISTILLER_CATALOG, } from './distill-llm.js';
+export { readDistillMode, writeDistillMode, DEFAULT_DISTILL_MODE_PATH, type DistillMode, type DistillModeState, } from './distill-mode.js';
+export { DEFAULT_CAPTURES_DIR, DEFAULT_DISTILL_CAPTURE_LIMIT, DEFAULT_EPISODES_DIR, DEFAULT_SKILLS_INSTALL_DIR, coveredSessionIds, episodeToCapturedTask, localSkillProvenance, loadRecentCaptures, loadRecentDistillSources, provenanceLabels, stagingDirFor, type DistillSourceOptions, } from './distill-captures.js';
+export { clusterTraceCards, readTrace, searchTraceCards, traceCardFromCapture, type EvidenceTierEstimate, type EstimatedDistillCost, type LocalTraceCard, type TraceCandidate, type TraceEventView, type TraceReadMode, type TraceReadResult, type TraceSearchQuery, } from './distill-traces.js';
+export { createDistillMcpServer, runLocalDistill, type DistillMcpDeps, type LocalDistillRunArgs, } from './distill-mcp-server.js';
+export { DEFAULT_DISTILL_FEEDBACK_PATH, distillFeedbackPathFromEnv, readDistillFeedback, recordDistillFeedback, type DistillFeedbackInput, type DistillFeedbackRecord, type DistillFeedbackVerdict, } from './distill-feedback.js';
+export { threeArmMeasurement, pilotPower, type ArmResult, type ArmComparison, type PilotPower, type ThreeArmResult, type ShipVerdict, } from './measurement.js';
+export { createFileLedger, createMemoryLedger, ledger, toLedgerRow, LedgerEntrySchema, LedgerRowSchema, DEFAULT_LEDGER_PATH, type LedgerEntry, type LedgerRow, type LedgerStore, } from './ledger.js';
+export { createGithubSeedSource, parseSeedListEntry, SeedSkillSchema, type SeedSkill, type SeedSource, type SeedListEntry, } from './seed-import/fetch.js';
+export { checkLicence, IMPORT_LICENCE_ALLOWLIST, type LicenceVerdict } from './seed-import/licence.js';
+export { plan } from './seed-import/plan.js';
+export { execute, skillSlug, type ImportResult } from './seed-import/execute.js';
+export { parseImportReport, renderImportReport, ImportReportSchema, type ImportReport, type ImportReportRow, } from './seed-import/report.js';
+export { createLocalEpisodeSeedSource, episodeContentDigest, parseSeedEpisode, SeedEpisodeSchema, SEED_EPISODE_EXCERPT_LABELS, type SeedEpisode, type SeedEpisodeStep, type SeedEpisodeExcerptLabel, type EpisodeSource, } from './seed-import/episode-fetch.js';
+export { planEpisodes } from './seed-import/episode-plan.js';
+export { executeEpisodes, type EpisodeImportResult } from './seed-import/episode-execute.js';
+export { parseEpisodeImportReport, renderEpisodeImportReport, EpisodeImportReportSchema, type EpisodeImportReport, type EpisodeImportReportRow, } from './seed-import/episode-report.js';
+export { createMemorySeedImportState, createFileSeedImportState, hashSeedContent, DEFAULT_SEED_IMPORT_STATE_PATH, type SeedImportStateStore, type SeedPublicationRecord, type FileSeedImportStateOptions, } from './seed-import/state.js';
+export { TraceEnvelopeV0Schema, TraceStepSchema, VerifiabilityTierSchema, OutcomeStatusSchema, parseTraceEnvelopeV0, TRACE_ENVELOPE_SCHEMA_VERSION, MAX_STEPS, MAX_STEP_ATTRIBUTES_BYTES, MAX_DISTRIBUTION_TAGS, VERIFIABILITY_TIERS, type TraceEnvelopeV0, type TraceStep, type VerifiabilityTier, type OutcomeStatus, } from './envelope.js';
+export { CONTRIBUTION_STORE_FILE, CONTRIBUTION_STORE_SCHEMA_VERSION, CONTRIBUTION_PUBLICATION_SCHEMA_VERSION, CONTRIBUTION_PUBLICATION_DISABLED_FILE, DEFAULT_CONTRIBUTION_STATE_DIR, ContributionStore, resolveContributionStateDir, type ContributionLocalMetadata, type ContributionPublicationV1, type ContributionStoreLockOptions, type ContributionStoreOptions, type ContributionStoreRecordOptions, type ContributionStoreReferenceOptions, type ContributionStoreRecord, } from '@jinn-network/core';
+export { PROCESS_CONTRACT_VERSION, SessionEndRequestV1Schema, SessionPickupRequestV1Schema, envelope as processEnvelope, sessionEndEnvelope, type ProcessEnvelope, type ProcessStatus, type SessionEndRequestV1, type SessionPickupEnvelope, type SessionPickupRequestV1, contributionLedgerRow, type ContributionLedgerRowV1, } from './process-contract.js';
+export { resolveRetrievalMark, HAND_MARK_POLICY, type AdmissionPolicy, type AdmissionFacts, } from './admission-policy.js';
+export { runJinnLayerCli, createBoundedIpfsJsonFetcher, type RunJinnLayerCliOptions, type DistillRunCliDeps, type DistillCliDeps, type DistillProvider, type JinnLayerWriter, } from './cli.js';
+export { buildPluginDepsFromEnv, buildPluginFromEnv, } from './plugin-wiring.js';
+export { createContributionAdapter, createContributionStatusStore, createCorpusAdapter, createEvidenceAdapter, createLocalLearningAdapter, createSkillsAdapter, } from './adapters/index.js';
+export { SqliteCorpusStore } from './corpus-store.js';
+export { extractSnapshotTranscript, findSolveTranscript, untarGz, unwrapDonation, MAX_SNAPSHOT_DECOMPRESSED_BYTES, type SolveTranscript, type TarEntry, } from './snapshot-transcript.js';
+export { auditCuratedSeedBatch, CURATED_SEED_AUDIT_SCHEMA_VERSION, type AuditCuratedSeedBatchOptions, type CuratedSeedBatchAudit, type CuratedSeedRecordAudit, } from './seed-import/curated-batch.js';

package/dist/index.js

@@ -0,0 +1,50 @@
+/**
+ * @jinn-network/jinn-layer — standalone plugin process and embeddable layer.
+ *
+ * v0 exposes the corpus consume path (search/get), the frozen layer-1 trace
+ * envelope read-compat schema, the capture path (scrub + preview), and the publish path
+ * (consent conversion + anchor + contribution ledger).
+ */
+export { createHarnessLayer, DEFAULT_IPFS_GATEWAY_URL, } from './consume.js';
+export { corpusProbes, enoughCorpusForRepo, CORPUS_ONBOARDING_K, } from './corpus-probes.js';
+export { capture, parseCapturedTask, CapturedTaskSchema, CaptureScrubError, PENDING_ENVELOPE_KIND, } from './capture.js';
+export { preview, stripBeforeValues, } from './preview.js';
+export { computeSignal, } from './signal.js';
+export { publish, PublishLedgerError, toPublishedEpisode, toTraceEnvelope, EPISODE_ARTIFACT_TYPE, TRACE_ENVELOPE_ARTIFACT_TYPE, } from './publish.js';
+export { extractSkill, } from './skill.js';
+export { SKILL_ARTIFACT_TYPE, SkillArtifactV1Schema, SkillProvenanceSchema, SkillCompanionFileSchema, MAX_SKILL_FILES, MAX_SKILL_TOTAL_DECODED_BYTES, } from '@jinn-network/core';
+export { buildSkillMarkdown, parseSkillMarkdown, assertConformantName, SkillPackageMetaSchema, } from './skill-package.js';
+export { publishSkill, toSkillArtifactV1, SKILL_SOLVER_TYPE, } from './publish-skill.js';
+export { bridgeAttempts, toBridgeCapturedTask, repoFromInstanceId, buildBridgeEvidencePublisher, } from './bridge.js';
+export { evaluateEligibility, redactionHealth, } from './gate.js';
+export { distillClusters, lexicalContaminationScan, } from './distill.js';
+export { createLocalDistiller, createNetworkDistiller, createLocalSkillSink, NetworkDistillerNotWiredError, } from './distiller.js';
+export { createClaudeDistiller, createClaudeMetaDistiller, createCodexDistiller, createCodexMetaDistiller, DEFAULT_MODEL as DEFAULT_CLAUDE_DISTILL_MODEL, DEFAULT_CODEX_MODEL, DISTILLER_CATALOG, } from './distill-llm.js';
+export { readDistillMode, writeDistillMode, DEFAULT_DISTILL_MODE_PATH, } from './distill-mode.js';
+export { DEFAULT_CAPTURES_DIR, DEFAULT_DISTILL_CAPTURE_LIMIT, DEFAULT_EPISODES_DIR, DEFAULT_SKILLS_INSTALL_DIR, coveredSessionIds, episodeToCapturedTask, localSkillProvenance, loadRecentCaptures, loadRecentDistillSources, provenanceLabels, stagingDirFor, } from './distill-captures.js';
+export { clusterTraceCards, readTrace, searchTraceCards, traceCardFromCapture, } from './distill-traces.js';
+export { createDistillMcpServer, runLocalDistill, } from './distill-mcp-server.js';
+export { DEFAULT_DISTILL_FEEDBACK_PATH, distillFeedbackPathFromEnv, readDistillFeedback, recordDistillFeedback, } from './distill-feedback.js';
+export { threeArmMeasurement, pilotPower, } from './measurement.js';
+export { createFileLedger, createMemoryLedger, ledger, toLedgerRow, LedgerEntrySchema, LedgerRowSchema, DEFAULT_LEDGER_PATH, } from './ledger.js';
+export { createGithubSeedSource, parseSeedListEntry, SeedSkillSchema, } from './seed-import/fetch.js';
+export { checkLicence, IMPORT_LICENCE_ALLOWLIST } from './seed-import/licence.js';
+export { plan } from './seed-import/plan.js';
+export { execute, skillSlug } from './seed-import/execute.js';
+export { parseImportReport, renderImportReport, ImportReportSchema, } from './seed-import/report.js';
+// Evidence-episode seed lane (issue #1771).
+export { createLocalEpisodeSeedSource, episodeContentDigest, parseSeedEpisode, SeedEpisodeSchema, SEED_EPISODE_EXCERPT_LABELS, } from './seed-import/episode-fetch.js';
+export { planEpisodes } from './seed-import/episode-plan.js';
+export { executeEpisodes } from './seed-import/episode-execute.js';
+export { parseEpisodeImportReport, renderEpisodeImportReport, EpisodeImportReportSchema, } from './seed-import/episode-report.js';
+export { createMemorySeedImportState, createFileSeedImportState, hashSeedContent, DEFAULT_SEED_IMPORT_STATE_PATH, } from './seed-import/state.js';
+export { TraceEnvelopeV0Schema, TraceStepSchema, VerifiabilityTierSchema, OutcomeStatusSchema, parseTraceEnvelopeV0, TRACE_ENVELOPE_SCHEMA_VERSION, MAX_STEPS, MAX_STEP_ATTRIBUTES_BYTES, MAX_DISTRIBUTION_TAGS, VERIFIABILITY_TIERS, } from './envelope.js';
+export { CONTRIBUTION_STORE_FILE, CONTRIBUTION_STORE_SCHEMA_VERSION, CONTRIBUTION_PUBLICATION_SCHEMA_VERSION, CONTRIBUTION_PUBLICATION_DISABLED_FILE, DEFAULT_CONTRIBUTION_STATE_DIR, ContributionStore, resolveContributionStateDir, } from '@jinn-network/core';
+export { PROCESS_CONTRACT_VERSION, SessionEndRequestV1Schema, SessionPickupRequestV1Schema, envelope as processEnvelope, sessionEndEnvelope, contributionLedgerRow, } from './process-contract.js';
+export { resolveRetrievalMark, HAND_MARK_POLICY, } from './admission-policy.js';
+export { runJinnLayerCli, createBoundedIpfsJsonFetcher, } from './cli.js';
+export { buildPluginDepsFromEnv, buildPluginFromEnv, } from './plugin-wiring.js';
+export { createContributionAdapter, createContributionStatusStore, createCorpusAdapter, createEvidenceAdapter, createLocalLearningAdapter, createSkillsAdapter, } from './adapters/index.js';
+export { SqliteCorpusStore } from './corpus-store.js';
+export { extractSnapshotTranscript, findSolveTranscript, untarGz, unwrapDonation, MAX_SNAPSHOT_DECOMPRESSED_BYTES, } from './snapshot-transcript.js';
+export { auditCuratedSeedBatch, CURATED_SEED_AUDIT_SCHEMA_VERSION, } from './seed-import/curated-batch.js';

package/dist/ipfs-cid.d.ts

@@ -0,0 +1,18 @@
+/** Kubo's default fixed chunk size and largest single raw-leaf block. */
+export declare const MAX_RAW_IPFS_BLOCK_BYTES: number;
+export declare const IPFS_RAW_CODEC = 85;
+export declare const IPFS_DAG_PB_CODEC = 112;
+/** Deterministic CIDv1 base16 identity for one exact raw sha2-256 block. */
+export declare function rawSha256Cid(bodyBytes: Uint8Array): string;
+export interface ParsedIpfsCid {
+    version: 0 | 1;
+    codec: typeof IPFS_RAW_CODEC | typeof IPFS_DAG_PB_CODEC;
+    sha256Digest: Uint8Array;
+}
+export declare function parseIpfsCid(value: string): ParsedIpfsCid | null;
+export declare function isIpfsCid(value: string): boolean;
+/**
+ * Assert the manifest boundary's strict address/content invariant before an
+ * irreversible anchor: canonical CIDv1 raw + sha2-256 over the exact bytes.
+ */
+export declare function assertRawSha256CidMatches(cid: string, bodyBytes: Uint8Array): void;

package/dist/ipfs-cid.js

@@ -0,0 +1,149 @@
+// SPDX-License-Identifier: Apache-2.0
+import { createHash } from 'node:crypto';
+/**
+ * CID validation for harness-layer network boundaries. Keep this package-local:
+ * the harness-layer ↔ client/src architecture seam is shrink-only.
+ *
+ * The live Autonolas registry emits CIDv1 raw objects, including the historical
+ * base16 form `f01551220<sha256>`. We deliberately support only the two codecs
+ * used by the Jinn/IPFS paths (raw and dag-pb) and only sha2-256 multihashes.
+ */
+const BASE58BTC = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const BASE32 = 'abcdefghijklmnopqrstuvwxyz234567';
+/** Kubo's default fixed chunk size and largest single raw-leaf block. */
+export const MAX_RAW_IPFS_BLOCK_BYTES = 256 * 1024;
+export const IPFS_RAW_CODEC = 0x55;
+export const IPFS_DAG_PB_CODEC = 0x70;
+/** Deterministic CIDv1 base16 identity for one exact raw sha2-256 block. */
+export function rawSha256Cid(bodyBytes) {
+    const digest = createHash('sha256').update(bodyBytes).digest('hex');
+    return `f01551220${digest}`;
+}
+export function parseIpfsCid(value) {
+    if (value.startsWith('Qm')) {
+        const bytes = decodeBase58(value);
+        // CIDv0 is specifically a dag-pb sha2-256 multihash.
+        if (bytes?.length !== 34
+            || bytes[0] !== 0x12
+            || bytes[1] !== 0x20) {
+            return null;
+        }
+        return {
+            version: 0,
+            codec: IPFS_DAG_PB_CODEC,
+            sha256Digest: bytes.slice(2),
+        };
+    }
+    let bytes;
+    if (value.startsWith('b')) {
+        // The supported 36-byte CIDv1 shape has one canonical 58-symbol base32
+        // encoding. Reject zero-extended textual aliases before decoding so CID
+        // strings remain safe cache/deduplication and metadata-key identities.
+        if (value.length !== 59)
+            return null;
+        bytes = decodeBase32(value.slice(1));
+    }
+    else if (value.startsWith('f')) {
+        const body = value.slice(1);
+        bytes = /^[0-9a-f]+$/u.test(body) ? decodeBase16(body) : null;
+    }
+    else if (value.startsWith('F')) {
+        const body = value.slice(1);
+        bytes = /^[0-9A-F]+$/u.test(body) ? decodeBase16(body) : null;
+    }
+    else {
+        return null;
+    }
+    // Supported CIDv1 values are exactly:
+    // version(01) + codec(raw=55|dag-pb=70) + sha2-256(12 20 <32 bytes>).
+    if (bytes?.length !== 36
+        || bytes[0] !== 0x01
+        || (bytes[1] !== IPFS_RAW_CODEC && bytes[1] !== IPFS_DAG_PB_CODEC)
+        || bytes[2] !== 0x12
+        || bytes[3] !== 0x20) {
+        return null;
+    }
+    return {
+        version: 1,
+        codec: bytes[1],
+        sha256Digest: bytes.slice(4),
+    };
+}
+export function isIpfsCid(value) {
+    return parseIpfsCid(value) !== null;
+}
+/**
+ * Assert the manifest boundary's strict address/content invariant before an
+ * irreversible anchor: canonical CIDv1 raw + sha2-256 over the exact bytes.
+ */
+export function assertRawSha256CidMatches(cid, bodyBytes) {
+    const parsed = parseIpfsCid(cid);
+    if (!parsed) {
+        throw new Error('manifest CID must be a canonical CIDv1 raw value with a 32-byte sha2-256 multihash');
+    }
+    if (parsed.version !== 1) {
+        throw new Error(`manifest CID must use CIDv1, got version ${parsed.version}`);
+    }
+    if (parsed.codec !== IPFS_RAW_CODEC) {
+        throw new Error(`manifest CID must use the raw codec (0x55), got 0x${parsed.codec.toString(16)}`);
+    }
+    const expected = createHash('sha256').update(bodyBytes).digest();
+    if (!Buffer.from(parsed.sha256Digest).equals(expected)) {
+        throw new Error('manifest CID digest does not match the canonical body digest');
+    }
+}
+function decodeBase58(value) {
+    const bytes = [0];
+    for (const char of value) {
+        const digit = BASE58BTC.indexOf(char);
+        if (digit < 0)
+            return null;
+        let carry = digit;
+        for (let index = bytes.length - 1; index >= 0; index -= 1) {
+            const next = bytes[index] * 58 + carry;
+            bytes[index] = next & 0xff;
+            carry = next >>> 8;
+        }
+        while (carry > 0) {
+            bytes.unshift(carry & 0xff);
+            carry >>>= 8;
+        }
+    }
+    for (const char of value) {
+        if (char !== '1')
+            break;
+        bytes.unshift(0);
+    }
+    return Uint8Array.from(bytes);
+}
+function decodeBase32(value) {
+    const bytes = [];
+    let accumulator = 0;
+    let bits = 0;
+    for (const char of value) {
+        const digit = BASE32.indexOf(char);
+        if (digit < 0)
+            return null;
+        accumulator = (accumulator << 5) | digit;
+        bits += 5;
+        while (bits >= 8) {
+            bits -= 8;
+            bytes.push((accumulator >>> bits) & 0xff);
+        }
+    }
+    if (bits !== 0 && (accumulator & ((1 << bits) - 1)) !== 0)
+        return null;
+    return Uint8Array.from(bytes);
+}
+function decodeBase16(value) {
+    if (value.length === 0 || value.length % 2 !== 0)
+        return null;
+    const bytes = new Uint8Array(value.length / 2);
+    for (let index = 0; index < value.length; index += 2) {
+        const byte = Number.parseInt(value.slice(index, index + 2), 16);
+        if (!Number.isInteger(byte))
+            return null;
+        bytes[index / 2] = byte;
+    }
+    return bytes;
+}

package/dist/layer-default.d.ts

@@ -0,0 +1,3 @@
+import { type HarnessLayer } from './consume.js';
+/** Shared environment-resolved corpus layer for CLI and plugin composition. */
+export declare function buildDefaultLayer(): HarnessLayer;

package/dist/layer-default.js

@@ -0,0 +1,10 @@
+import { createHarnessLayer } from './consume.js';
+/** Shared environment-resolved corpus layer for CLI and plugin composition. */
+export function buildDefaultLayer() {
+    return createHarnessLayer({
+        ...(process.env['JINN_DISCOVERY_URL'] ? { discoveryUrl: process.env['JINN_DISCOVERY_URL'] } : {}),
+        ...(process.env['JINN_IPFS_GATEWAY_URL']
+            ? { ipfsGatewayUrl: process.env['JINN_IPFS_GATEWAY_URL'] }
+            : {}),
+    });
+}

package/dist/ledger.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Contribution ledger — the operator's local receipt of what left their
+ * machine (plan Task 4, issue #1311).
+ *
+ * Append-only JSONL at `~/.jinn-client/harness-layer/ledger.jsonl` by
+ * default. Entries carry only persistence-safe fields (the task summary is
+ * already scrubbed by capture; redaction `before` values never reach here).
+ * The Task 5 fork renders this; Task 7 aggregates over it.
+ */
+import { z } from 'zod';
+export declare const DEFAULT_LEDGER_PATH: string;
+export declare const LedgerEntrySchema: z.ZodObject<{
+    ts: z.ZodISODateTime;
+    taskSummary: z.ZodString;
+    envelopeRef: z.ZodNullable<z.ZodString>;
+    anchorTx: z.ZodNullable<z.ZodString>;
+    verifiabilityTier: z.ZodEnum<{
+        "user-accepted": "user-accepted";
+        "tests-passed": "tests-passed";
+        "evaluator-verified": "evaluator-verified";
+    }>;
+    status: z.ZodEnum<{
+        published: "published";
+        "vetoed (local only)": "vetoed (local only)";
+    }>;
+}, z.core.$strict>;
+export type LedgerEntry = z.infer<typeof LedgerEntrySchema>;
+/**
+ * Fork-shaped projection of a ledger entry — the row shape the TUI consumer
+ * (`apps/jinn-agent/plugins/jinn/ledger_view.py`, `rows_from_json`) reads.
+ * `state` is absent for published rows; the schema also accepts a `failed`
+ * state for forward-compat, even though `toLedgerRow` never emits it.
+ */
+export declare const LedgerRowSchema: z.ZodObject<{
+    time: z.ZodString;
+    task: z.ZodString;
+    env: z.ZodNullable<z.ZodString>;
+    anchor: z.ZodNullable<z.ZodString>;
+    tier: z.ZodEnum<{
+        "user-accepted": "user-accepted";
+        "tests-passed": "tests-passed";
+        "evaluator-verified": "evaluator-verified";
+    }>;
+    state: z.ZodOptional<z.ZodEnum<{
+        failed: "failed";
+        vetoed: "vetoed";
+    }>>;
+}, z.core.$strict>;
+export type LedgerRow = z.infer<typeof LedgerRowSchema>;
+/** Project an internal ledger entry into the fork-consumed row shape. */
+export declare function toLedgerRow(entry: LedgerEntry): LedgerRow;
+export interface LedgerStore {
+    append(entry: LedgerEntry): void;
+    /** Entries in append order. */
+    list(): LedgerEntry[];
+}
+/** In-memory ledger (tests, embedders that persist elsewhere). */
+export declare function createMemoryLedger(): LedgerStore;
+/** Append-only JSONL file ledger. Creates parent directories on first write. */
+export declare function createFileLedger(path?: string): LedgerStore;
+/** Read the ledger (plan Task 4's `ledger()` surface). Missing file ⇒ empty. */
+export declare function ledger(path?: string): LedgerEntry[];