@jinn-network/jinn-layer 0.1.0

package/dist/process-contract.js

@@ -0,0 +1,118 @@
+import { z } from 'zod';
+import { ContributionCandidateV1Schema, EpisodeV1WriteSchema, JINN_PLUGIN_CONTRACT_VERSION, PickupConfigSchema, SessionActivityFactsWriteSchema, } from '@jinn-network/plugin';
+export const PROCESS_CONTRACT_VERSION = JINN_PLUGIN_CONTRACT_VERSION;
+export const PROCESS_STATUSES = ['ok', 'degraded', 'unavailable'];
+const SessionMetaSchema = z.strictObject({
+    sessionId: z.string().min(1).max(128),
+    taskSummary: z.string().min(1),
+    distributionTags: z.array(z.string().min(1)).optional(),
+    harness: z.strictObject({ name: z.string().min(1), version: z.string().min(1) }),
+    model: z.string().min(1),
+    tools: z.array(z.string().min(1)),
+    skillsLoadout: z.array(z.string().min(1)).optional(),
+    pickup: PickupConfigSchema.optional(),
+    /** Fed into `deriveSearchTerms`'s repo-slug bonus (rescope §3.3). Additive — absent is fine. */
+    repositorySlug: z.string().min(1).optional(),
+    kind: z.enum(['user', 'host-internal']).optional(),
+    parentSessionId: z.string().min(1).max(128).optional(),
+});
+export const SessionPickupRequestV1Schema = z.strictObject({
+    contractVersion: z.literal(PROCESS_CONTRACT_VERSION),
+    meta: SessionMetaSchema,
+    firstMessage: z.string(),
+});
+export const SessionEndRequestV1Schema = z.strictObject({
+    contractVersion: z.literal(PROCESS_CONTRACT_VERSION),
+    episode: EpisodeV1WriteSchema,
+    activity: SessionActivityFactsWriteSchema,
+    eligibilityInputs: z.strictObject({
+        publicRepo: z.boolean().optional(),
+        acceptedDiff: z.boolean().optional(),
+    }),
+    contributionCandidate: ContributionCandidateV1Schema.optional(),
+    contributionVetoed: z.boolean().optional(),
+});
+export function envelope(status, value, reason) {
+    return {
+        contractVersion: PROCESS_CONTRACT_VERSION,
+        status,
+        ...(value !== undefined ? { value } : {}),
+        ...(reason !== undefined ? { reason } : {}),
+    };
+}
+export function sessionEndEnvelope(result) {
+    if (result.persistence.status === 'unavailable') {
+        return envelope('unavailable', result, result.persistence.reason);
+    }
+    const reasons = [];
+    if (result.persistence.status === 'degraded')
+        reasons.push(result.persistence.reason);
+    if (result.contribution?.status === 'degraded' || result.contribution?.status === 'unavailable') {
+        reasons.push(result.contribution.reason);
+    }
+    return envelope(reasons.length > 0 ? 'degraded' : 'ok', result, reasons[0]);
+}
+/** Track pickup port health without repeating requests merely to classify output. */
+export function trackingCorpus(deps) {
+    let status = 'ok';
+    let reason;
+    const observe = (result) => {
+        if (result.status === 'unavailable' || (result.status === 'degraded' && status === 'ok')) {
+            status = result.status;
+            reason = result.reason;
+        }
+        return result;
+    };
+    return {
+        deps: {
+            ...deps,
+            corpus: {
+                async search(query) { return observe(await deps.corpus.search(query)); },
+                async get(ref) { return observe(await deps.corpus.get(ref)); },
+            },
+            skills: {
+                async install(ref) { return observe(await deps.skills.install(ref)); },
+                async list() { return observe(await deps.skills.list()); },
+                async uninstall(ref) { return observe(await deps.skills.uninstall(ref)); },
+            },
+        },
+        status: () => status,
+        reason: () => reason,
+    };
+}
+/**
+ * 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 function sessionPickupEnvelope(result, observedStatus, observedReason) {
+    const reason = result.degraded ?? observedReason;
+    if (observedStatus === 'unavailable' && result.packets.length === 0) {
+        return envelope('unavailable', result, reason);
+    }
+    const status = observedStatus === 'ok' && reason === undefined ? 'ok' : 'degraded';
+    return envelope(status, result, reason);
+}
+function displayTimestamp(value) {
+    if (value === undefined)
+        return null;
+    const match = /^\d{4}-(\d{2})-(\d{2})T(\d{2}):(\d{2})/u.exec(value);
+    return match ? `${match[1]}-${match[2]} ${match[3]}:${match[4]}` : value;
+}
+/** Persistence-safe terminal projection. Local IDs and candidate evidence do not cross it. */
+export function contributionLedgerRow(entry) {
+    const published = entry.status === 'published';
+    const repository = entry.repositorySlug ?? 'repository unavailable';
+    const commit = entry.baseCommit ? entry.baseCommit.slice(0, 8) : 'commit unavailable';
+    return {
+        time: displayTimestamp(entry.createdAt),
+        task: `${repository} @ ${commit}`,
+        env: published ? entry.mintRef ?? null : null,
+        anchor: published ? entry.publicationRef ?? null : null,
+        tier: entry.verifiabilityTier ?? null,
+        state: entry.status,
+    };
+}

package/dist/publish-skill.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Publish a layer-2 `jinn.skill.v1` package as a corpus record
+ * (spec/2026-07-06-distillation-v1.md §5, reconciled 2026-07-07 with the
+ * shipped #1394 substrate).
+ *
+ * This is the **distilled-skill producer** #1394 anticipated but did not ship:
+ * the artifact payload is the canonical `SkillArtifactV1`
+ * (client/src/types/skill-artifact.ts) with `provenance.kind: 'distilled'` and
+ * the DR-2026-07-06 distill fields (`skillKind`, `distillPromptSha256`,
+ * `distribution`, `verifiabilityTier`). The stored `skill.skillMd` is rendered
+ * WITHOUT the `metadata.jinn` frontmatter block — the structured provenance
+ * object is canonical; embedding a second copy would drift (use
+ * `buildSkillMarkdown(pkg)` in EXPORT mode to write a standalone SKILL.md).
+ *
+ * A distilled skill has no trace of its own (its evidence is the referenced
+ * layer-1 envelopes in `provenance.sourceEnvelopeCids`), so this publishes a
+ * **skill-only wrapper** — unlike the seed path, which attaches the skill
+ * alongside the seeded trace via `publish(pending, deps, { skill })`.
+ *
+ * The wrapper envelope is discriminated as `solverType: 'distilled-skill'`.
+ * `role` stays `'capture'` — it is a closed enum (`CanonicalRoleSchema`), so a
+ * `'knowledge'` role is unavailable without amending the execution-envelope
+ * schema (out of scope). The anchor uses a distinct `skill:<cid>` metadata key
+ * so a skill payload is not routed into `captureEnvelopeMeta` enrichment
+ * (which requires a trace-envelope artifact).
+ *
+ * NOTE (producer wiring deferred to Plan A5 — issue #1439): the `skill:<cid>`
+ * key requested below is honored by the injected `anchorEnvelope` dep and by
+ * the indexer's `parseEnvelopeKey` (which registers `skill` as a fourth kind),
+ * but the shipped production anchor wiring (`publishContentV2` → `buildMetadataKey`,
+ * whose `ContentKind` union is closed to `envelope|evaluation|capture`) does
+ * NOT yet emit it — so a live publish currently anchors under
+ * `capture:<cid>`. Extending `ContentKind` to `skill` is the A5 round-trip
+ * prerequisite (#1439). Until then the distinct-key / anti-enrichment guarantee
+ * holds in tests and in the indexer, not on the live anchor path.
+ */
+import type { CaptureEnvelopeAnchorInput, CaptureEnvelopeAnchorResult, CapturePublishedBlob } from './execution-publish.js';
+import type { SignedEnvelope, UnsignedEnvelope } from '@jinn-network/core';
+import { type SkillArtifactV1 } from '@jinn-network/core';
+import { type SkillPackage } from './skill-package.js';
+export declare const SKILL_SOLVER_TYPE: "distilled-skill";
+export interface SkillPublishDeps {
+    participant: {
+        safeAddress: `0x${string}`;
+        agentEoa: `0x${string}`;
+    };
+    signer: {
+        address: `0x${string}`;
+        privateKey?: `0x${string}`;
+    };
+    clientGitSha: string;
+    /** Upload the skill artifact payload (a SkillArtifactV1) as a blob. */
+    publishArtifact: (input: {
+        artifactType: string;
+        payload: unknown;
+    }) => Promise<CapturePublishedBlob>;
+    /** Upload the signed wrapper envelope; its CID is the corpus ref. */
+    publishEnvelope: (envelope: SignedEnvelope) => Promise<CapturePublishedBlob>;
+    /** Anchor the envelope on-chain (ERC-8004). */
+    anchorEnvelope: (input: CaptureEnvelopeAnchorInput) => Promise<CaptureEnvelopeAnchorResult>;
+    /** Custom signer (e.g. remote key); default signs with signer.privateKey. */
+    signEnvelope?: (unsigned: UnsignedEnvelope) => Promise<SignedEnvelope['signature']>;
+    /** Access endpoint recorded on the artifact when the blob has none. */
+    defaultArtifactEndpoint?: string;
+    now?: () => Date;
+}
+export interface PublishSkillResult {
+    envelopeRef: string;
+    anchorTx: `0x${string}` | null;
+}
+/**
+ * Supersede lineage a publish may stamp on a skill record (issue #1462).
+ * Lifecycle is *content* — not an injected collaborator — so it rides an
+ * optional param, preserving the deps/content seam and keeping every existing
+ * 2-arg call site working. Honored at read time only when the successor's
+ * operator matches the superseded record's operator (client/.../consume.ts).
+ */
+export interface SkillLifecycle {
+    /** Envelope/manifest CID of the prior record this one replaces. */
+    supersedes?: string;
+    /** Pure retirement marker: retires `supersedes` with no replacement. */
+    deprecates?: boolean;
+}
+/** Map the distiller-side SkillPackage onto the canonical SkillArtifactV1. */
+export declare function toSkillArtifactV1(pkg: SkillPackage, operatorSafeAddress: `0x${string}`, lifecycle?: SkillLifecycle): SkillArtifactV1;
+export declare function publishSkill(pkg: SkillPackage, deps: SkillPublishDeps, lifecycle?: SkillLifecycle): Promise<PublishSkillResult>;

package/dist/publish-skill.js

@@ -0,0 +1,116 @@
+import { buildUnsignedCaptureEnvelope, sha256Hex, } from './execution-publish.js';
+import { SignedEnvelopeSchema } from '@jinn-network/core';
+import { SKILL_ARTIFACT_TYPE, SkillArtifactV1Schema, } from '@jinn-network/core';
+import { signCanonical } from './signing.js';
+import { canonicalJson } from '@jinn-network/core';
+import { EMPTY_BUNDLE_SHA256 } from '@jinn-network/core/trajectory';
+import { buildSkillMarkdown } from './skill-package.js';
+const DONATION_ARTIFACT_ENCODING = 'jinn.artifact.donation.v1';
+const DEFAULT_PRICE_USDC = '0';
+export const SKILL_SOLVER_TYPE = 'distilled-skill';
+/** Map the distiller-side SkillPackage onto the canonical SkillArtifactV1. */
+export function toSkillArtifactV1(pkg, operatorSafeAddress, lifecycle) {
+    return SkillArtifactV1Schema.parse({
+        schemaVersion: SKILL_ARTIFACT_TYPE,
+        skill: {
+            name: pkg.name,
+            description: pkg.description,
+            // Canonical stored form: provenance lives ONLY in the structured object
+            // below — render the SKILL.md without the metadata.jinn block.
+            skillMd: buildSkillMarkdown(pkg, { embedProvenance: false }),
+        },
+        files: [],
+        provenance: {
+            kind: 'distilled',
+            sourceEnvelopeCids: pkg.jinn.provenance,
+            operator: { safeAddress: operatorSafeAddress },
+            solverType: SKILL_SOLVER_TYPE,
+            ...(pkg.jinn.skillKind !== undefined ? { skillKind: pkg.jinn.skillKind } : {}),
+            ...(pkg.jinn.distillPromptSha256 !== undefined
+                ? { distillPromptSha256: pkg.jinn.distillPromptSha256 }
+                : {}),
+            distribution: pkg.jinn.distribution,
+            verifiabilityTier: pkg.jinn.verifiabilityTier,
+            // Auditability (§5, v0.5): the distilling model + compression-ratio estimates.
+            ...(pkg.jinn.distillModel !== undefined ? { distillModel: pkg.jinn.distillModel } : {}),
+            ...(pkg.jinn.evidenceTokens !== undefined ? { evidenceTokens: pkg.jinn.evidenceTokens } : {}),
+            ...(pkg.jinn.skillTokens !== undefined ? { skillTokens: pkg.jinn.skillTokens } : {}),
+            // Supersede lineage (#1462).
+            ...(lifecycle?.supersedes !== undefined ? { supersedes: lifecycle.supersedes } : {}),
+            ...(lifecycle?.deprecates !== undefined ? { deprecates: lifecycle.deprecates } : {}),
+        },
+    });
+}
+export async function publishSkill(pkg, deps, lifecycle) {
+    const now = deps.now?.() ?? new Date();
+    const skillArtifact = toSkillArtifactV1(pkg, deps.participant.safeAddress, lifecycle);
+    const blob = await deps.publishArtifact({
+        artifactType: SKILL_ARTIFACT_TYPE,
+        payload: skillArtifact,
+    });
+    // canonicalJson matches the live uploader's serialization (publish-live.ts)
+    // and the sibling publish() fallback — JSON.stringify would hash different
+    // bytes than were uploaded (key order / whitespace) and break verification.
+    const sha256 = blob.sha256 ?? sha256Hex(canonicalJson(skillArtifact));
+    const endpoint = blob.endpoint ?? deps.defaultArtifactEndpoint;
+    if (!endpoint) {
+        throw new Error(`published skill artifact ${blob.cid} has no access endpoint (set defaultArtifactEndpoint)`);
+    }
+    const artifact = {
+        artifactType: SKILL_ARTIFACT_TYPE,
+        sha256,
+        metadata: { description: `Distilled skill: ${pkg.name}` },
+        access: { endpoint, priceUsdc: blob.priceUsdc ?? DEFAULT_PRICE_USDC },
+        sources: [{ kind: 'ipfs', cid: blob.cid, sha256, encoding: DONATION_ARTIFACT_ENCODING }],
+    };
+    // A skill carries no capture spans; synthesise the minimal PendingCaptureRow
+    // the envelope builder reads for provenance. The resulting wrapper carries a
+    // cosmetic `payload.capture` block (sessionId `skill:<name>`, spanCount 0) —
+    // an artifact of reusing the capture builder; consumers discriminate on
+    // solverType/artifactType, never on that block.
+    //
+    // Ledger note: unlike publish(), no contribution-ledger entry is written
+    // here — a distilled skill derives from ALREADY-consented, already-ledgered
+    // evidence (its sourceEnvelopeCids); there is no fresh consent event to
+    // record. Revisit if skills ever gain their own consent surface.
+    const captureRow = {
+        sessionId: `skill:${pkg.name}`,
+        capturedAt: now.toISOString(),
+        originatingTool: { name: 'jinn-distiller', version: '0.1.0' },
+        capturePath: 'A',
+        spanCount: 0,
+        redactedSpanCount: 0,
+        durationMs: 0,
+    };
+    const unsigned = buildUnsignedCaptureEnvelope({
+        capture: captureRow,
+        now,
+        participant: deps.participant,
+        signerAddress: deps.signer.address,
+        clientGitSha: deps.clientGitSha,
+        artifacts: [artifact],
+        harnessBundleSha: EMPTY_BUNDLE_SHA256,
+        solverType: SKILL_SOLVER_TYPE,
+        role: 'capture',
+    });
+    const signature = deps.signEnvelope
+        ? await deps.signEnvelope(unsigned)
+        : await signWithPrivateKey(unsigned, deps);
+    const envelope = SignedEnvelopeSchema.parse({ ...unsigned, signature });
+    const envelopeBlob = await deps.publishEnvelope(envelope);
+    const envelopeRef = envelopeBlob.cid;
+    const anchor = await deps.anchorEnvelope({
+        metadataKey: `skill:${envelopeRef}`,
+        envelopeCid: envelopeRef,
+        envelopeHash: envelope.signature.hash,
+        envelope,
+    });
+    return { envelopeRef, anchorTx: anchor.txHash ?? null };
+}
+async function signWithPrivateKey(unsigned, deps) {
+    if (!deps.signer.privateKey) {
+        throw new Error('publishSkill() requires signer.privateKey or a signEnvelope dependency');
+    }
+    const signed = await signCanonical(unsigned, deps.signer.privateKey, deps.signer.address);
+    return { algo: 'secp256k1', signer: signed.signer, hash: signed.hash, sig: signed.sig };
+}

package/dist/publish.d.ts

@@ -0,0 +1,294 @@
+/**
+ * Harness-layer publish path (plan Task 4, issue #1311).
+ *
+ * `publish(pending)` performs the consent conversion (calling publish after
+ * preview IS the consent action), projects the scrubbed pending capture into
+ * a canonical EpisodeV1 artifact, and wraps it in the same signed
+ * `jinn.execution.v1` envelope the daemon capture path publishes (reusing
+ * `buildUnsignedCaptureEnvelope`), and anchors it via ERC-8004. Publishing
+ * through that wrapper is what makes the returned ref resolvable with
+ * `jinn-layer corpus get <ref>` — the corpus reads signed envelopes, so the
+ * contribute → anchored → discoverable round trip closes.
+ *
+ * No-bypass: only a `PendingEnvelope` produced by `capture()` (which ran the
+ * mandatory scrub, fail-closed) can be published — enforced by the parameter
+ * type and a runtime kind gate. There is no code path from raw spans to
+ * `publish()`.
+ *
+ * Per-task veto: `opts.veto` publishes nothing and records a ledger entry
+ * marked `vetoed (local only)` — the operator's receipt that the trace
+ * existed and was withheld.
+ *
+ * v0 anchors directly per publish (testnet); the batch relayer is v0.5 work
+ * alongside earning.
+ */
+import type { CaptureEnvelopeAnchorInput, CaptureEnvelopeAnchorResult, CapturePublishedBlob } from './execution-publish.js';
+import type { SignedEnvelope, UnsignedEnvelope } from '@jinn-network/core';
+import { type SkillArtifactV1 } from '@jinn-network/core';
+import { type EpisodeV1Write } from '@jinn-network/plugin';
+import { type ManifestV0, type ManifestPayload } from '@jinn-network/core';
+import { type PendingEnvelope } from './capture.js';
+import { type TraceEnvelopeV0 } from './envelope.js';
+import type { LedgerStore } from './ledger.js';
+/** Read-compat only: no new capture publication emits this payload. */
+export declare const TRACE_ENVELOPE_ARTIFACT_TYPE: "jinn.trace-envelope.v0";
+/** Canonical local/public evidence payload emitted by new publications. */
+export declare const EPISODE_ARTIFACT_TYPE: "jinn.episode.v1";
+export interface HarnessPublishDeps {
+    participant: {
+        safeAddress: `0x${string}`;
+        agentEoa: `0x${string}`;
+    };
+    signer: {
+        address: `0x${string}`;
+        privateKey?: `0x${string}`;
+    };
+    clientGitSha: string;
+    /** Upload an evidence or companion payload as an artifact blob. */
+    publishArtifact: (input: {
+        artifactType: string;
+        payload: unknown;
+    }) => Promise<CapturePublishedBlob>;
+    /** Upload the signed wrapper envelope; its CID is the corpus ref. */
+    publishEnvelope: (envelope: SignedEnvelope) => Promise<CapturePublishedBlob>;
+    /** Anchor the envelope on-chain (ERC-8004). */
+    anchorEnvelope: (input: CaptureEnvelopeAnchorInput) => Promise<CaptureEnvelopeAnchorResult>;
+    /** Custom signer (e.g. remote key); default signs with signer.privateKey. */
+    signEnvelope?: (unsigned: UnsignedEnvelope) => Promise<SignedEnvelope['signature']>;
+    /** The contribution ledger every publish/veto is recorded in. */
+    ledger: LedgerStore;
+    /** Access endpoint recorded on the artifact when the blob has none. */
+    defaultArtifactEndpoint?: string;
+    now?: () => Date;
+}
+export interface ManifestAnchorResult {
+    txHash: `0x${string}`;
+    blockNumber: number | null;
+    gasUsed: bigint | null;
+    feeWei: bigint | null;
+}
+export type ManifestAnchorReconciliation = ({
+    status: 'confirmed';
+} & ManifestAnchorResult) | {
+    status: 'reverted';
+    txHash: `0x${string}`;
+} | {
+    status: 'pending';
+    txHash: `0x${string}`;
+};
+export interface ManifestBatchJournalStore {
+    loadManifestBatchJournal(batchKey: string): string | null;
+    saveManifestBatchJournal(batchKey: string, stateJson: string): void;
+    compareAndSwapManifestBatchJournal(batchKey: string, expectedStateJson: string | null, nextStateJson: string): boolean;
+}
+export interface ManifestPublicationScope {
+    chainId: number;
+    identityRegistryAddress: `0x${string}`;
+    agentId: string;
+}
+export interface ManifestAnchorRecord {
+    manifestCid: string;
+    contentKind: 'manifest';
+    metadataKey: string;
+    payloadHex: `0x${string}`;
+    txHash: `0x${string}`;
+    blockNumber: number | null;
+    gasUsed: bigint | null;
+    feeWei: bigint | null;
+    anchoredAt: number;
+}
+export interface PerRecordControlAnchorRecord {
+    envelopeRef: string;
+    contentKind: 'capture';
+    metadataKey: string;
+    payloadHex: `0x${string}`;
+    txHash: `0x${string}`;
+    blockNumber: number | null;
+    gasUsed: bigint;
+    feeWei: bigint;
+    anchoredAt: number;
+}
+export interface ManifestBatchPublishDeps extends HarnessPublishDeps {
+    publishManifestBody(body: ManifestV0): Promise<CapturePublishedBlob>;
+    /**
+     * Read-only recovery check for a durably journaled upload intent. `absent`
+     * is safe only when the backing store can authoritatively prove absence;
+     * gateway/read failures must return `unknown`.
+     */
+    reconcileManifestBody?(expectedCid: string, bodyBytes: Uint8Array): Promise<{
+        status: 'present';
+    } | {
+        status: 'absent';
+    } | {
+        status: 'unknown';
+        reason?: string;
+    }>;
+    anchorManifest(input: {
+        manifestCid: string;
+        payload: ManifestPayload;
+        onBroadcast?: (txHash: `0x${string}`) => void;
+    }): Promise<ManifestAnchorResult>;
+    /** Durable live-only recovery journal. */
+    manifestJournal?: ManifestBatchJournalStore;
+    /** Exact on-chain identity targeted by a durable recovery journal. */
+    manifestPublicationScope?: ManifestPublicationScope;
+    /** Read-only reconciliation for a previously journaled transaction. */
+    reconcileAnchor?(txHash: `0x${string}`): Promise<ManifestAnchorReconciliation>;
+    recordManifestAnchor(input: ManifestAnchorRecord): void;
+    /** Required only by the explicit paired gas-measurement control. */
+    recordControlAnchor?(input: PerRecordControlAnchorRecord): void;
+    log?: (line: string) => void;
+}
+export interface ManifestBatchMemberInput {
+    pending: PendingEnvelope;
+    polarity?: 'pass' | 'fail';
+    instanceId?: string;
+    /** Immutable upstream identity used to key durable recovery. */
+    sourceId?: string;
+}
+export interface ManifestBatchOptions {
+    batchKind: string;
+    /** Add one receipt-bound per-record control tx for the first uploaded member. */
+    measurePerRecordControl?: boolean;
+}
+export interface PublishedMemberEnvelope {
+    envelopeRef: string;
+    sha256: string;
+    envelope: SignedEnvelope;
+    /** Frozen read-compatible projection used by the in-process distillation pipeline. */
+    trace: TraceEnvelopeV0;
+    /** Canonical payload actually uploaded and signed for new publications. */
+    episode: EpisodeV1Write;
+}
+export interface ManifestBatchResult {
+    /** Durable recovery identity, present when a journal is active. */
+    batchKey?: string;
+    manifestCid: string;
+    anchorTx: `0x${string}`;
+    memberRefs: string[];
+    root: `0x${string}`;
+    gasUsed: bigint | null;
+    feeWei: bigint | null;
+    control?: {
+        memberRef: string;
+        anchorTx: `0x${string}`;
+        blockNumber: number | null;
+        gasUsed: bigint | null;
+        feeWei: bigint | null;
+    };
+}
+export interface ManifestBatchSetResult {
+    /** One entry per raw-block-sized manifest, in member order. */
+    batches: ManifestBatchResult[];
+    /** Every uploaded member ref, including refs in a later failed partition. */
+    memberRefs: string[];
+    /** Exact frozen member envelopes, including journal-resumed publications. */
+    publishedMembers: PublishedMemberEnvelope[];
+}
+export interface PublishOptions {
+    /** Per-task veto: record locally, publish nothing. */
+    veto?: boolean;
+    /**
+     * First-class skill artifact (#1394): validated against
+     * SkillArtifactV1Schema and published as a second artifact on the SAME
+     * wrapper envelope, alongside (never instead of) the canonical episode.
+     */
+    skill?: SkillArtifactV1;
+}
+export interface PublishedResult {
+    vetoed: false;
+    envelopeRef: string;
+    anchorTx: `0x${string}` | null;
+}
+export type PublishResult = PublishedResult | {
+    vetoed: true;
+};
+/**
+ * The irreversible publish/anchor succeeded, but the local contribution
+ * ledger receipt could not be appended. Ordinary callers receive a failure;
+ * recovery-aware seed callers may persist `result` before stopping.
+ */
+export declare class PublishLedgerError extends Error {
+    readonly result: PublishedResult;
+    readonly ledgerError: unknown;
+    readonly name = "PublishLedgerError";
+    constructor(result: PublishedResult, ledgerError: unknown);
+}
+export declare class ManifestBatchRecordingError extends Error {
+    readonly result: ManifestBatchResult;
+    readonly recordingError: unknown;
+    readonly batchKey: string | null;
+    readonly name = "ManifestBatchRecordingError";
+    readonly txHash: `0x${string}` | null;
+    constructor(result: ManifestBatchResult, recordingError: unknown, batchKey: string | null);
+    readonly memberRefs: string[];
+}
+/**
+ * A partitioned manifest publish failed. Retain both any completed irreversible
+ * anchors and every uploaded member ref so the caller can reconcile without
+ * retrying successful work.
+ */
+export declare class ManifestBatchSetError extends Error {
+    readonly completed: ManifestBatchResult[];
+    readonly failed: unknown;
+    readonly memberRefs: string[];
+    readonly batchKey: string | null;
+    readonly name = "ManifestBatchSetError";
+    constructor(completed: ManifestBatchResult[], failed: unknown, memberRefs: string[], batchKey: string | null);
+}
+export declare class ManifestBatchPreparationError extends Error {
+    readonly stage: 'member-upload' | 'partition' | 'manifest-upload' | 'manifest-validation' | 'manifest-preparation';
+    readonly memberRefs: string[];
+    readonly preparationError: unknown;
+    readonly batchKey: string | null;
+    readonly name = "ManifestBatchPreparationError";
+    constructor(stage: 'member-upload' | 'partition' | 'manifest-upload' | 'manifest-validation' | 'manifest-preparation', memberRefs: string[], preparationError: unknown, batchKey: string | null);
+}
+/**
+ * The manifest body is already content-addressed, but the durable anchor
+ * state could not advance safely. A callback hash is retained when known;
+ * a hashless write-ahead intent deliberately remains closed to retry.
+ */
+export declare class ManifestBatchAnchorError extends Error {
+    readonly manifestCid: string;
+    readonly memberRefs: string[];
+    readonly root: `0x${string}`;
+    readonly anchorError: unknown;
+    readonly batchKey: string | null;
+    readonly name = "ManifestBatchAnchorError";
+    readonly txHash: `0x${string}` | null;
+    constructor(manifestCid: string, memberRefs: string[], root: `0x${string}`, anchorError: unknown, batchKey: string | null);
+}
+/**
+ * Consent conversion: the pre-consent draft becomes a full TraceEnvelopeV0
+ * with both consent flags literal `true`. Valid only for capture()-produced
+ * pending envelopes (runtime kind gate) and re-validated against the frozen
+ * schema on the way out.
+ */
+export declare function toTraceEnvelope(pending: PendingEnvelope): TraceEnvelopeV0;
+/**
+ * Project the scrubbed pending capture into the same canonical contract the
+ * local evidence store uses. Consent remains the publish action and is not a
+ * second payload field; trace-envelope.v0 remains available only to legacy
+ * readers.
+ */
+export declare function toPublishedEpisode(pending: PendingEnvelope): EpisodeV1Write;
+/**
+ * Consent, upload, and sign one pending member without anchoring or writing the
+ * contribution ledger. Both the per-record and manifest paths share this exact
+ * byte-producing step so batch mode cannot drift into a second envelope format.
+ */
+export declare function publishMemberEnvelope(pending: PendingEnvelope, deps: HarnessPublishDeps, opts?: Pick<PublishOptions, 'skill'> & {
+    now?: Date;
+}): Promise<PublishedMemberEnvelope>;
+/**
+ * Publish a pending envelope: consent conversion → artifact upload → signed
+ * wrapper envelope → ERC-8004 anchor → ledger entry. Returns the corpus ref
+ * (the wrapper envelope's CID) and the anchor tx.
+ */
+export declare function publish(pending: PendingEnvelope, deps: HarnessPublishDeps, opts?: PublishOptions): Promise<PublishResult>;
+/**
+ * Upload substrate members once, partition their manifest bodies at Kubo's
+ * raw-block boundary, and anchor exactly once per resulting manifest.
+ */
+export declare function publishManifestBatch(members: ManifestBatchMemberInput[], deps: ManifestBatchPublishDeps, opts: ManifestBatchOptions): Promise<ManifestBatchSetResult>;