@jinn-network/jinn-layer 0.1.0

package/dist/adapters/contribution-adapter.d.ts

@@ -0,0 +1,18 @@
+import { type ContributionPort, type EvidencePort } from '@jinn-network/plugin';
+import { ContributionStore } from '@jinn-network/core';
+/** Compatibility name retained for existing composition roots. */
+export type ContributionStatusStore = ContributionStore;
+/**
+ * Compatibility factory retained for callers that previously supplied a
+ * sidecar status-file path. It now opens the canonical contribution store at
+ * exactly that path, so adapter writes and daemon reads share one file.
+ */
+export declare function createContributionStatusStore(path: string): ContributionStatusStore;
+export interface ContributionAdapterDeps {
+    /** `statusStore` is retained as a source-compatible dependency name. */
+    statusStore: ContributionStatusStore;
+    /** Canonical payload resolver; the status store contains references only. */
+    evidence: Pick<EvidencePort, 'get'>;
+    now?: () => string;
+}
+export declare function createContributionAdapter(deps: ContributionAdapterDeps): ContributionPort;

package/dist/adapters/contribution-adapter.js

@@ -0,0 +1,134 @@
+/** ContributionPort projection over the shared daemon/jinn-layer store. */
+import { isDeepStrictEqual } from 'node:util';
+import { deriveContributionStatus, degraded, ok, unavailable, ContributionCandidateV1ProjectionSchema, ContributionCandidateV1Schema, } from '@jinn-network/plugin';
+import { ContributionStore } from '@jinn-network/core';
+/**
+ * Compatibility factory retained for callers that previously supplied a
+ * sidecar status-file path. It now opens the canonical contribution store at
+ * exactly that path, so adapter writes and daemon reads share one file.
+ */
+export function createContributionStatusStore(path) {
+    return new ContributionStore({ filePath: path });
+}
+function snapshot(record) {
+    if (!record)
+        return null;
+    return {
+        localState: record.localState,
+        publicationState: record.publicationState,
+        ...(record.mintRef ? { mintRef: record.mintRef } : {}),
+        ...(record.publicationRef ? { publicationRef: record.publicationRef } : {}),
+        status: deriveContributionStatus(record),
+    };
+}
+export function createContributionAdapter(deps) {
+    const store = deps.statusStore;
+    const now = deps.now ?? (() => new Date().toISOString());
+    return {
+        async recordMineable(candidate, options) {
+            try {
+                const parsed = ContributionCandidateV1Schema.parse(candidate);
+                const evidence = await deps.evidence.get(parsed.sourceId);
+                const episode = evidence.status === 'unavailable' ? null : evidence.value;
+                const canonicalCandidate = episode?.contributionCandidate === undefined
+                    ? undefined
+                    : ContributionCandidateV1ProjectionSchema.safeParse(episode.contributionCandidate);
+                if (!episode) {
+                    return unavailable(`canonical contribution episode is unavailable: ${parsed.sourceId}`);
+                }
+                if (!canonicalCandidate?.success
+                    || canonicalCandidate.data.sourceId !== episode.episodeId
+                    || !isDeepStrictEqual(canonicalCandidate.data, parsed)) {
+                    return unavailable(`canonical contribution candidate mismatch: ${parsed.sourceId}`);
+                }
+                const record = await store.recordReference(parsed.sourceId, {
+                    publishMinedTasksConsent: parsed.publishMinedTasksConsent,
+                    ...options,
+                });
+                return ok({ recordId: record.recordId });
+            }
+            catch (error) {
+                return unavailable(`contribution store recordMineable failed: ${String(error)}`);
+            }
+        },
+        async ledger() {
+            try {
+                const reasons = [];
+                const entries = await Promise.all((await store.list()).map(async (record) => {
+                    const evidence = await deps.evidence.get(record.recordId);
+                    const episode = evidence.status === 'unavailable' ? null : evidence.value;
+                    const parsedCandidate = episode?.contributionCandidate === undefined
+                        ? undefined
+                        : ContributionCandidateV1ProjectionSchema.safeParse(episode.contributionCandidate);
+                    const candidate = parsedCandidate?.success && parsedCandidate.data.sourceId === record.recordId
+                        ? parsedCandidate.data
+                        : undefined;
+                    if (!candidate)
+                        reasons.push(`unresolved canonical episode: ${record.recordId}`);
+                    return {
+                        recordId: record.recordId,
+                        sourceId: record.recordId,
+                        ...(candidate ? {
+                            createdAt: candidate.createdAt,
+                            verifiabilityTier: candidate.testRuns.some((run) => run.exitCode === 0)
+                                ? 'tests-passed'
+                                : 'user-accepted',
+                            repositorySlug: candidate.repositorySlug,
+                            baseCommit: candidate.baseCommit,
+                        } : {}),
+                        localState: record.localState,
+                        publicationState: record.publicationState,
+                        ...(record.mintRef ? { mintRef: record.mintRef } : {}),
+                        ...(record.publicationRef ? { publicationRef: record.publicationRef } : {}),
+                        status: deriveContributionStatus(record),
+                    };
+                }));
+                return reasons.length > 0
+                    ? degraded([...new Set(reasons)].join('; '), entries)
+                    : ok(entries);
+            }
+            catch (error) {
+                return unavailable(`contribution ledger failed: ${String(error)}`);
+            }
+        },
+        async mintStatus(recordId) {
+            try {
+                const value = snapshot(await store.get(recordId));
+                return value ? ok(value) : unavailable(`no such record: ${recordId}`);
+            }
+            catch (error) {
+                return unavailable(`contribution status failed: ${String(error)}`);
+            }
+        },
+        async authorize(recordId) {
+            try {
+                const record = await store.authorize(recordId, now());
+                const status = deriveContributionStatus(record);
+                if (record.publicationState !== 'queued' || status !== 'queued') {
+                    return unavailable(`contribution ${recordId} did not enter the queued state`);
+                }
+                return ok({ recordId, publicationState: 'queued', status: 'queued' });
+            }
+            catch (error) {
+                return unavailable(`contribution authorization failed: ${String(error)}`);
+            }
+        },
+        async veto(recordId) {
+            try {
+                await store.veto(recordId);
+                return ok({ recordId, publicationState: 'vetoed', status: 'vetoed' });
+            }
+            catch (error) {
+                return unavailable(`contribution veto failed: ${String(error)}`);
+            }
+        },
+        async disableUnpublished() {
+            try {
+                return ok({ recordIds: await store.disableUnpublished() });
+            }
+            catch (error) {
+                return unavailable(`contribution disable failed: ${String(error)}`);
+            }
+        },
+    };
+}

package/dist/adapters/corpus-adapter.d.ts

@@ -0,0 +1,12 @@
+import type { CorpusPort } from '@jinn-network/plugin';
+import { type HarnessLayer, type HarnessLayerConfig } from '../consume.js';
+export interface CorpusAdapterDeps {
+    /** A ready HarnessLayer (test seam: a fake `{ corpus: { search, get } }`). */
+    layer: HarnessLayer;
+}
+/**
+ * Build a CorpusPort over a HarnessLayer. Pass `{ layer }` (a real or fake
+ * layer) or a `HarnessLayerConfig` (a real layer is constructed via
+ * `createHarnessLayer`).
+ */
+export declare function createCorpusAdapter(deps: CorpusAdapterDeps | HarnessLayerConfig): CorpusPort;

package/dist/adapters/corpus-adapter.js

@@ -0,0 +1,212 @@
+/**
+ * CorpusPort adapter (#1660; content-bearing get() per Stage 1 rescope R2,
+ * #1772) — shims `HarnessLayer.corpus` onto the plugin's `CorpusPort`.
+ * `search` maps `CorpusSearchHit[]` → `KnowledgeHit[]`, carrying the
+ * evidence-first selection fields (tags/origin/publishedAt) alongside the
+ * pre-existing title/snippet. `get` decodes and sha256-verifies the
+ * `jinn.trace-envelope.v0` artifact the same way the Python
+ * `skills_install._extract_trace` path does, returning full content — not
+ * metadata — or a typed degraded reason on a corrupt/unreadable record.
+ */
+import { createHash } from 'node:crypto';
+import { degraded, EpisodeV1Schema, ok, hasRetrievalMark, RETRIEVAL_VISIBLE_TAG, } from '@jinn-network/plugin';
+import { createHarnessLayer, } from '../consume.js';
+import { parseTraceEnvelopeV0 } from '../envelope.js';
+import { EPISODE_ARTIFACT_TYPE, TRACE_ENVELOPE_ARTIFACT_TYPE, } from '../publish.js';
+import { SKILL_ARTIFACT_TYPE } from '@jinn-network/core';
+function isLayerDeps(deps) {
+    return 'layer' in deps;
+}
+/**
+ * `CorpusSearchHit` → `KnowledgeHit`. `summary` → `snippet`; `score` omitted.
+ * `origin` is the identity used by cross-record content dedup: prefer the
+ * on-chain-derived `agentId`, otherwise use the record ref so unattributed
+ * records cannot collide through a forged manifest `safeAddress`.
+ */
+function toKnowledgeHit(hit) {
+    const origin = hit.operator.agentId || hit.ref;
+    const tags = hit.tags ?? [];
+    // Named indexed metadata is authoritative when present. The legacy mark is
+    // only a fallback for rows indexed before that field existed.
+    const retrievalVisible = hit.retrievalVisible ?? hasRetrievalMark(tags);
+    return {
+        ref: hit.ref,
+        kind: hit.kind === 'skill' ? 'skill' : 'trace',
+        ...(hit.title ? { title: hit.title } : {}),
+        ...(hit.summary ? { snippet: hit.summary } : {}),
+        tags: tags.filter((tag) => tag !== RETRIEVAL_VISIBLE_TAG),
+        ...(origin ? { origin } : {}),
+        publishedAt: hit.publishedAt,
+        retrievalVisible,
+    };
+}
+function seedStepSynthesis(steps) {
+    for (const step of steps) {
+        const value = step.attributes['seed.synthesis'];
+        if (typeof value === 'string' && value.trim().length > 0)
+            return value;
+    }
+    return undefined;
+}
+/**
+ * True when any step carries a string `skill.md` attribute — the legacy
+ * pre-#1394 seed shape (`seed-import/execute.ts` `toCapturedTask`). Checks
+ * every step, not only one named `seed:skill-md`: the wire shape this guard
+ * exists for already lied about `kind` once, so detection here keys on the
+ * attribute itself, not a step-naming convention layered on top of it.
+ */
+function hasSkillMdAttribute(steps) {
+    return steps.some((step) => {
+        const value = step.attributes['skill.md'];
+        return typeof value === 'string' && value.length > 0;
+    });
+}
+/**
+ * Content-level skill-payload classification (mono #1782): true when the
+ * record is a skill package regardless of the search hit's wire `kind` —
+ * either a first-class `jinn.skill.v1` artifact (checked by presence only,
+ * not parsed/validated here — parsing a malformed skill artifact's body is
+ * `extractSkill()`'s job, and must not be able to fail *this* guard), or the
+ * legacy seeded shape `hasSkillMdAttribute` recognises.
+ */
+function detectSkillPayload(record, steps) {
+    if (record.artifacts.some((a) => a.artifactType === SKILL_ARTIFACT_TYPE))
+        return true;
+    return hasSkillMdAttribute(steps);
+}
+function decodeEvidencePayload(artifactType, content) {
+    const body = JSON.parse(content.toString('utf-8'));
+    if (artifactType === EPISODE_ARTIFACT_TYPE) {
+        const declaresRetrievalVisible = body !== null
+            && typeof body === 'object'
+            && Object.prototype.hasOwnProperty.call(body, 'retrievalVisible');
+        const episode = EpisodeV1Schema.parse(body);
+        return {
+            task: episode.task,
+            ...(declaresRetrievalVisible
+                ? { retrievalVisible: episode.retrievalVisible }
+                : {}),
+            outcome: episode.outcome,
+            steps: episode.trajectory,
+            provenance: episode.provenance,
+            capturedAt: episode.session.capturedAt,
+        };
+    }
+    const trace = parseTraceEnvelopeV0(body);
+    return {
+        task: trace.task,
+        retrievalVisible: hasRetrievalMark(trace.task.distributionTags),
+        outcome: {
+            status: trace.outcome.status,
+            verificationStrength: trace.outcome.verifiabilityTier,
+            ...(trace.outcome.summary ? { summary: trace.outcome.summary } : {}),
+        },
+        steps: trace.steps,
+        provenance: trace.provenance,
+        capturedAt: trace.session.capturedAt,
+    };
+}
+/**
+ * Decode the record's canonical `jinn.episode.v1` artifact (or frozen
+ * `jinn.trace-envelope.v0` read-compat artifact) into the plugin's
+ * content-bearing `CorpusRecord`. Verifies the artifact bytes against the
+ * record's own sha256 before parsing — a mismatch refuses to serve
+ * unverified content (mirrors Python `_extract_trace`). Returns `null` when
+ * the record carries no trace-envelope artifact (e.g. a skill-only record;
+ * pickup selection never fetches these, but the port stays honest for any
+ * other caller).
+ */
+function decodeRecord(record) {
+    const artifact = record.artifacts.find((a) => a.artifactType === EPISODE_ARTIFACT_TYPE)
+        ?? record.artifacts.find((a) => a.artifactType === TRACE_ENVELOPE_ARTIFACT_TYPE);
+    if (!artifact)
+        return null;
+    const actualSha256 = createHash('sha256').update(artifact.content).digest('hex');
+    if (actualSha256 !== artifact.sha256) {
+        throw new Error(`sha256 mismatch decoding ${record.ref} — expected ${artifact.sha256.slice(0, 12)}…, `
+            + `got ${actualSha256.slice(0, 12)}… — refusing to serve unverified content`);
+    }
+    const evidence = decodeEvidencePayload(artifact.artifactType, artifact.content);
+    // Packet attribution is display-only, so safeAddress remains an acceptable
+    // fallback here after trustworthy agentId; it is never used for hit dedup.
+    const origin = record.provenance.operator.agentId || record.provenance.operator.safeAddress || record.ref;
+    const synthesis = evidence.outcome.summary ?? seedStepSynthesis(evidence.steps);
+    // Fails open (mono #1782): a detection error never blocks the rest of the
+    // record's content from being served — it just leaves the fact
+    // undetermined, exactly as if this guard did not exist for that record.
+    let isSkillPayload = false;
+    try {
+        isSkillPayload = detectSkillPayload(record, evidence.steps);
+    }
+    catch {
+        isSkillPayload = false;
+    }
+    // Content remains the guard: a named canonical boolean is authoritative
+    // when the raw body declared it, and only legacy absence falls back to the
+    // compatibility mark.
+    const retrievalVisible = evidence.retrievalVisible ?? hasRetrievalMark(evidence.task.distributionTags);
+    return {
+        ref: record.ref,
+        task: {
+            summary: evidence.task.summary,
+            ...(evidence.task.repositorySlug
+                ? { repositorySlug: evidence.task.repositorySlug }
+                : {}),
+        },
+        outcome: {
+            status: evidence.outcome.status,
+            verifiabilityTier: evidence.outcome.verificationStrength,
+        },
+        ...(synthesis ? { synthesis } : {}),
+        steps: evidence.steps.map((step) => ({ name: step.name, attributes: step.attributes })),
+        // Deliberately un-stripped (unlike the search-hit path): CorpusRecord.tags
+        // is provenance-adjacent display data on the fetched packet, never fed to
+        // the scoring haystack — hiding the mark here would hide provenance.
+        tags: evidence.task.distributionTags,
+        retrievalVisible,
+        provenance: evidence.provenance,
+        origin,
+        capturedAt: evidence.capturedAt,
+        ...(isSkillPayload ? { isSkillPayload: true } : {}),
+    };
+}
+/**
+ * Build a CorpusPort over a HarnessLayer. Pass `{ layer }` (a real or fake
+ * layer) or a `HarnessLayerConfig` (a real layer is constructed via
+ * `createHarnessLayer`).
+ */
+export function createCorpusAdapter(deps) {
+    const layer = isLayerDeps(deps) ? deps.layer : createHarnessLayer(deps);
+    return {
+        async search(query) {
+            try {
+                const hits = await layer.corpus.search(query);
+                return ok(hits.map(toKnowledgeHit));
+            }
+            catch (e) {
+                // Empty array keeps callers alive when discovery is unreachable.
+                return degraded(`corpus search failed: ${String(e)}`, []);
+            }
+        },
+        async get(ref) {
+            let record;
+            try {
+                record = await layer.corpus.get(ref);
+            }
+            catch {
+                // `corpus.get` throws on a missing manifest, and the contract requires
+                // `ok(null)` for that unknown-ref path (Stage 1). A genuine transport
+                // error is currently indistinguishable from not-found via the throw, so
+                // it also collapses to `ok(null)` here; distinguishing the two is a
+                // follow-up on `consume.ts`'s `corpus.get` surface, not this shim.
+                return ok(null);
+            }
+            try {
+                return ok(decodeRecord(record));
+            }
+            catch (e) {
+                return degraded(`corpus record ${ref} failed to decode: ${String(e)}`, null);
+            }
+        },
+    };
+}

package/dist/adapters/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Harness-layer → plugin-port adapter shims (#1660, Stage 1).
+ *
+ * Each `createXAdapter(deps)` factory returns an object that `implements` the
+ * matching `@jinn-network/plugin` port and passes that port's
+ * `describeXPortContract` from `@jinn-network/plugin/testing`. Every method
+ * converts internal throws into a typed `PortResult` (`ok`/`degraded`/
+ * `unavailable`) so an adapter never crashes across the port boundary.
+ *
+ * The dependency arrow is one-way: harness-layer imports the ports/schemas
+ * FROM `@jinn-network/plugin`; the plugin package never imports `client/**`.
+ */
+export { createCorpusAdapter } from './corpus-adapter.js';
+export { createEvidenceAdapter, capturedTaskToEpisode } from '@jinn-network/core';
+export { createContributionAdapter, createContributionStatusStore, type ContributionStatusStore, } from './contribution-adapter.js';
+export { createLocalLearningAdapter } from './local-learning-adapter.js';
+export { createSkillsAdapter } from './skills-adapter.js';

package/dist/adapters/index.js

@@ -0,0 +1,17 @@
+/**
+ * Harness-layer → plugin-port adapter shims (#1660, Stage 1).
+ *
+ * Each `createXAdapter(deps)` factory returns an object that `implements` the
+ * matching `@jinn-network/plugin` port and passes that port's
+ * `describeXPortContract` from `@jinn-network/plugin/testing`. Every method
+ * converts internal throws into a typed `PortResult` (`ok`/`degraded`/
+ * `unavailable`) so an adapter never crashes across the port boundary.
+ *
+ * The dependency arrow is one-way: harness-layer imports the ports/schemas
+ * FROM `@jinn-network/plugin`; the plugin package never imports `client/**`.
+ */
+export { createCorpusAdapter } from './corpus-adapter.js';
+export { createEvidenceAdapter, capturedTaskToEpisode } from '@jinn-network/core';
+export { createContributionAdapter, createContributionStatusStore, } from './contribution-adapter.js';
+export { createLocalLearningAdapter } from './local-learning-adapter.js';
+export { createSkillsAdapter } from './skills-adapter.js';

package/dist/adapters/json-map-store.d.ts

@@ -0,0 +1,4 @@
+/** Read the JSON map at `path`. Missing / corrupt / non-object ⇒ `{}`. */
+export declare function readJsonMap<T>(path: string): Record<string, T>;
+/** Atomically write `map` to `path` (temp + rename), creating the dir. */
+export declare function writeJsonMap<T>(path: string, map: Record<string, T>): void;

package/dist/adapters/json-map-store.js

@@ -0,0 +1,31 @@
+/**
+ * Tiny file-backed JSON-map primitive shared by the file-backed adapters
+ * (contribution status store, skills install index). Read-missing ⇒ `{}`;
+ * a corrupt or non-object file ⇒ `{}` (never throws on read). Writes are
+ * atomic (temp file + rename) and create the parent dir on demand.
+ *
+ * In-package on purpose: harness-layer must NOT reach into `client/src/**`
+ * (the one-way dependency arrow), so the mineable-store idiom is reproduced
+ * here rather than imported.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+/** Read the JSON map at `path`. Missing / corrupt / non-object ⇒ `{}`. */
+export function readJsonMap(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf-8'));
+        return parsed && typeof parsed === 'object' ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+/** Atomically write `map` to `path` (temp + rename), creating the dir. */
+export function writeJsonMap(path, map) {
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmp, JSON.stringify(map), 'utf-8');
+    renameSync(tmp, path);
+}

package/dist/adapters/local-learning-adapter.d.ts

@@ -0,0 +1,25 @@
+/**
+ * LocalLearningPort adapter (#1660) — drives the rung-1 `Distiller` behind the
+ * plugin's `LocalLearningPort`. `run` mints a runId, kicks the distillation
+ * asynchronously, and returns `ok({ runId })` immediately; a failed
+ * distillation is a `'failed'` run STATE, not a port error.
+ *
+ * The returned object exposes `awaitRun(runId)` beyond the port surface so
+ * tests can observe the terminal state deterministically (no timers).
+ */
+import type { LocalLearningPort, LocalLearningSkill } from '@jinn-network/plugin';
+import type { CapturedTask } from '../capture.js';
+import type { Distiller } from '../distiller.js';
+export interface LocalLearningAdapterDeps {
+    distiller: Distiller;
+    /** Resolve episodeIds → the captures the distiller consumes. */
+    loadCaptures: (episodeIds: string[]) => Promise<CapturedTask[]>;
+    /** Read durable skill state; unlike process-local run state this survives CLI invocations. */
+    listSkills?: () => Promise<LocalLearningSkill[]>;
+}
+/** The port plus a test-only completion handle. */
+export interface LocalLearningAdapter extends LocalLearningPort {
+    /** Resolve once the run reaches a terminal (`done`/`failed`) state. */
+    awaitRun(runId: string): Promise<void>;
+}
+export declare function createLocalLearningAdapter(deps: LocalLearningAdapterDeps): LocalLearningAdapter;

package/dist/adapters/local-learning-adapter.js

@@ -0,0 +1,49 @@
+import { ok, unavailable } from '@jinn-network/plugin';
+export function createLocalLearningAdapter(deps) {
+    const runs = new Map();
+    const completions = new Map();
+    let runCounter = 0;
+    return {
+        async run(input) {
+            runCounter += 1;
+            const runId = `run-${Date.now()}-${runCounter}`;
+            runs.set(runId, { runId, state: 'pending' });
+            const completion = (async () => {
+                runs.set(runId, { runId, state: 'running' });
+                try {
+                    const captures = await deps.loadCaptures(input.episodeIds);
+                    await deps.distiller.distill(captures);
+                    runs.set(runId, { runId, state: 'done' });
+                }
+                catch {
+                    // A failed distillation is a legitimate run state, not a port error.
+                    runs.set(runId, { runId, state: 'failed' });
+                }
+            })();
+            completions.set(runId, completion);
+            return ok({ runId });
+        },
+        async status(runId) {
+            const run = runs.get(runId);
+            if (!run)
+                return unavailable(`no such run: ${runId}`);
+            return ok(run);
+        },
+        async list() {
+            return ok([...runs.values()]);
+        },
+        async skills() {
+            if (!deps.listSkills)
+                return unavailable('local skill provenance is unavailable');
+            try {
+                return ok(await deps.listSkills());
+            }
+            catch (error) {
+                return unavailable(`local skill provenance failed: ${String(error)}`);
+            }
+        },
+        async awaitRun(runId) {
+            await completions.get(runId);
+        },
+    };
+}

package/dist/adapters/skills-adapter.d.ts

@@ -0,0 +1,8 @@
+import type { SkillsPort } from '@jinn-network/plugin';
+export interface SkillsAdapterDeps {
+    /** Skills-install dir. The registry index lives at `<installDir>/installed.json`. */
+    installDir: string;
+    /** Injectable clock (tests). */
+    now?: () => Date;
+}
+export declare function createSkillsAdapter(deps: SkillsAdapterDeps): SkillsPort;

package/dist/adapters/skills-adapter.js

@@ -0,0 +1,55 @@
+/**
+ * SkillsPort adapter (#1660) — a file-backed skills-install registry behind the
+ * plugin's `SkillsPort`. `install` records the ref (+ `installedAt`); `list`
+ * enumerates installed refs; `uninstall` removes a ref unconditionally
+ * (idempotent, matching the in-memory reference which `.delete()`s regardless).
+ *
+ * Stage 1 records/lists/removes refs; on-disk `<name>/SKILL.md` parsing
+ * (`parseSkillMarkdown`/`assertConformantName`) is a later stage's concern.
+ */
+import { join } from 'node:path';
+import { ok, unavailable } from '@jinn-network/plugin';
+import { readJsonMap, writeJsonMap } from './json-map-store.js';
+const INDEX_FILE = 'installed.json';
+export function createSkillsAdapter(deps) {
+    const indexPath = join(deps.installDir, INDEX_FILE);
+    const now = deps.now ?? (() => new Date());
+    const readIndex = () => readJsonMap(indexPath);
+    const writeIndex = (index) => writeJsonMap(indexPath, index);
+    return {
+        async install(ref) {
+            try {
+                const index = readIndex();
+                const installedAt = now().toISOString();
+                index[ref] = { installedAt };
+                writeIndex(index);
+                return ok({ ref, installedAt });
+            }
+            catch (e) {
+                return unavailable(`skills install failed: ${String(e)}`);
+            }
+        },
+        async list() {
+            try {
+                const index = readIndex();
+                return ok(Object.entries(index).map(([ref, { installedAt }]) => ({ ref, installedAt })));
+            }
+            catch (e) {
+                return unavailable(`skills list failed: ${String(e)}`);
+            }
+        },
+        async uninstall(ref) {
+            try {
+                const index = readIndex();
+                if (ref in index) {
+                    delete index[ref];
+                    writeIndex(index);
+                }
+                return ok({ ref });
+            }
+            catch (e) {
+                return unavailable(`skills uninstall failed: ${String(e)}`);
+            }
+        },
+    };
+}

package/dist/admission-policy.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Policy-admission hook (issue #1824, corpus-supply-design §5, charter
+ * Decision 4 amendment): the intended publish-time chokepoint marking
+ * producers call before building distributionTags. Declared policies decide
+ * from record facts (verdict, evidence tier, tags, freshness, provenance);
+ * hand-marking (HAND_MARK_POLICY, 'hand.v0') is the day-one policy and
+ * admits nothing — the mark is set iff the curator explicitly requested it.
+ * Not yet wired into a producer: day-one hand-marking happens by the curated
+ * seed lane carrying RETRIEVAL_VISIBLE_TAG in the episode's own tags
+ * (seed-import/episode-execute.ts passes them through as distributionTags).
+ * Producers adopt this chokepoint when the first fact-based policy lands
+ * (B2+); enforcement (pickup ranking + post-fetch guard) needs no change.
+ */
+export interface AdmissionFacts {
+    verdict?: 'passed' | 'failed' | 'unknown';
+    evidenceTier?: string;
+    tags?: readonly string[];
+    capturedAt?: string;
+    provenance?: 'imported' | 'contributed';
+}
+export interface AdmissionPolicy {
+    name: string;
+    admit(facts: AdmissionFacts): boolean;
+}
+/** Day-one policy (#1824): admits nothing automatically. Marking authority
+ *  stays at publish time, by the curator's explicit request only. */
+export declare const HAND_MARK_POLICY: AdmissionPolicy;
+/**
+ * The chokepoint: `explicit` is the curator's hand-mark request; `policy`
+ * decides from `facts` when `explicit` is not itself true. Explicit wins
+ * outright — a policy can only ADD admission, never withdraw a curator's
+ * explicit request.
+ */
+export declare function resolveRetrievalMark(args: {
+    explicit?: boolean;
+    facts: AdmissionFacts;
+    policy: AdmissionPolicy;
+}): boolean;

package/dist/admission-policy.js

@@ -0,0 +1,17 @@
+/** Day-one policy (#1824): admits nothing automatically. Marking authority
+ *  stays at publish time, by the curator's explicit request only. */
+export const HAND_MARK_POLICY = {
+    name: 'hand.v0',
+    admit: () => false,
+};
+/**
+ * The chokepoint: `explicit` is the curator's hand-mark request; `policy`
+ * decides from `facts` when `explicit` is not itself true. Explicit wins
+ * outright — a policy can only ADD admission, never withdraw a curator's
+ * explicit request.
+ */
+export function resolveRetrievalMark(args) {
+    if (args.explicit === true)
+        return true;
+    return args.policy.admit(args.facts);
+}

package/dist/bin/jinn-distill-mcp.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { createDistillMcpServer } from '../distill-mcp-server.js';
+const server = createDistillMcpServer();
+const transport = new StdioServerTransport();
+server.connect(transport).catch((err) => {
+    console.error('[jinn-distill-mcp] failed to start');
+    console.error(err);
+    process.exit(1);
+});