@jinn-network/client 0.1.9 → 0.2.0

package/node_modules/@jinn-network/core/dist/trajectory/transcript-to-spans/codex-exec-json.js

@@ -0,0 +1,253 @@
+import { readFile } from 'node:fs/promises';
+import { CodexSessionParser } from '../transcript-parsers/codex-session.js';
+import { makeProvenanceAttrs, truncate, truncateLeaves } from './attrs.js';
+const SOURCE_FORMAT = 'codex-exec-json';
+const PARSER_NAME = 'codex-exec-json';
+const PARSER_VERSION = '1.1.0';
+class TimestampCursor {
+    lastGoodNs = 0n;
+    next(iso) {
+        const milliseconds = new Date(iso).getTime();
+        if (Number.isFinite(milliseconds)) {
+            const nanoseconds = BigInt(milliseconds) * 1000000n;
+            this.lastGoodNs = nanoseconds;
+            return String(nanoseconds);
+        }
+        this.lastGoodNs += 1n;
+        return String(this.lastGoodNs);
+    }
+}
+function provenanceAttrs() {
+    return makeProvenanceAttrs(SOURCE_FORMAT, PARSER_NAME, PARSER_VERSION);
+}
+/**
+ * `codex exec --json` stdout uses item lifecycle records, while Codex home
+ * sessions use timestamped `response_item` envelopes. Convert the direct
+ * stream to the same events consumed below; returning no events preserves the
+ * home-session compatibility fallback.
+ */
+function parseDirectExecEvents(rawText) {
+    const events = [];
+    const pendingCommandIds = new Set();
+    let syntheticTimestampMs = 0;
+    const nextTimestamp = () => new Date(syntheticTimestampMs++).toISOString();
+    for (const line of rawText.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let record;
+        try {
+            record = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if (!record || (record.type !== 'item.started' && record.type !== 'item.completed')) {
+            continue;
+        }
+        if (!record.item || typeof record.item !== 'object' || Array.isArray(record.item)) {
+            continue;
+        }
+        const item = record.item;
+        if (record.type === 'item.completed' &&
+            item.type === 'agent_message' &&
+            typeof item.text === 'string' &&
+            item.text.length > 0) {
+            events.push({
+                kind: 'assistant-message',
+                timestamp: nextTimestamp(),
+                content: item.text,
+            });
+            continue;
+        }
+        if (item.type !== 'command_execution' || typeof item.command !== 'string') {
+            continue;
+        }
+        const itemId = typeof item.id === 'string' ? item.id : null;
+        const hasPendingCall = itemId !== null && pendingCommandIds.has(itemId);
+        if (record.type === 'item.started') {
+            events.push({
+                kind: 'tool-call',
+                timestamp: nextTimestamp(),
+                name: 'command_execution',
+                args: { command: item.command },
+                ...(itemId !== null ? { correlationId: itemId } : {}),
+            });
+            if (itemId !== null)
+                pendingCommandIds.add(itemId);
+            continue;
+        }
+        // A completed-only stream still carries enough evidence for a full call.
+        if (!hasPendingCall) {
+            events.push({
+                kind: 'tool-call',
+                timestamp: nextTimestamp(),
+                name: 'command_execution',
+                args: { command: item.command },
+                ...(itemId !== null ? { correlationId: itemId } : {}),
+            });
+        }
+        if (itemId !== null)
+            pendingCommandIds.delete(itemId);
+        const output = typeof item.aggregated_output === 'string' ? item.aggregated_output : '';
+        const isError = (typeof item.exit_code === 'number' && item.exit_code !== 0) ||
+            item.status === 'failed';
+        events.push({
+            kind: 'tool-result',
+            timestamp: nextTimestamp(),
+            name: 'command_execution',
+            content: output,
+            isError,
+            ...(itemId !== null ? { correlationId: itemId } : {}),
+        });
+    }
+    return events;
+}
+function findTerminalUsage(rawText) {
+    let result = null;
+    for (const line of rawText.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        let object;
+        try {
+            object = JSON.parse(trimmed);
+        }
+        catch {
+            continue;
+        }
+        if ((object['type'] === 'turn.completed' || object['type'] === 'turn.failed') &&
+            object['usage']) {
+            const usage = object['usage'];
+            const inputTokens = usage['input_tokens'];
+            const outputTokens = usage['output_tokens'];
+            if (typeof inputTokens === 'number' && typeof outputTokens === 'number') {
+                result = { inputTokens, outputTokens };
+            }
+        }
+    }
+    return result;
+}
+export class CodexExecJsonParser {
+    sourceFormat = SOURCE_FORMAT;
+    parserName = PARSER_NAME;
+    parserVersion = PARSER_VERSION;
+    async parse(transcriptPath) {
+        let rawText;
+        try {
+            rawText = await readFile(transcriptPath, 'utf-8');
+        }
+        catch {
+            return [];
+        }
+        return this.parseText(rawText);
+    }
+    parseText(rawText) {
+        let events = parseDirectExecEvents(rawText);
+        if (events.length === 0) {
+            try {
+                const normalized = rawText.endsWith('\n') ? rawText : `${rawText}\n`;
+                events = new CodexSessionParser().parseChunk({
+                    sessionId: 'engine-pack',
+                    chunk: normalized,
+                });
+            }
+            catch {
+                return [];
+            }
+        }
+        const spans = [];
+        const pendingByName = new Map();
+        const pendingByCorrelationId = new Map();
+        const agentTurns = [];
+        const cursor = new TimestampCursor();
+        for (const event of events) {
+            switch (event.kind) {
+                case 'user-message':
+                case 'assistant-message': {
+                    const timestamp = cursor.next(event.timestamp);
+                    const turn = {
+                        name: `agent_turn.${event.kind === 'user-message' ? 'user' : 'assistant'}`,
+                        kind: 'INTERNAL',
+                        startTimeUnixNano: timestamp,
+                        endTimeUnixNano: timestamp,
+                        attributes: {
+                            'jinn.span.kind': 'jinn.agent_turn',
+                            'jinn.turn.role': event.kind === 'user-message' ? 'user' : 'assistant',
+                            'message.content': truncate(event.content),
+                            ...provenanceAttrs(),
+                        },
+                        events: [],
+                        status: { code: 'OK' },
+                    };
+                    spans.push(turn);
+                    agentTurns.push(turn);
+                    break;
+                }
+                case 'tool-call': {
+                    const timestamp = cursor.next(event.timestamp);
+                    const call = {
+                        name: `tool_call.${event.name}`,
+                        kind: 'INTERNAL',
+                        startTimeUnixNano: timestamp,
+                        endTimeUnixNano: timestamp,
+                        attributes: {
+                            'jinn.span.kind': 'jinn.tool_call',
+                            'tool.name': event.name,
+                            'tool.args': truncateLeaves(event.args),
+                            ...provenanceAttrs(),
+                        },
+                        events: [],
+                        status: { code: 'UNSET' },
+                    };
+                    spans.push(call);
+                    if (event.correlationId) {
+                        pendingByCorrelationId.set(event.correlationId, call);
+                    }
+                    else {
+                        const queue = pendingByName.get(event.name) ?? [];
+                        queue.push(call);
+                        pendingByName.set(event.name, queue);
+                    }
+                    break;
+                }
+                case 'tool-result': {
+                    let call;
+                    if (event.correlationId) {
+                        call = pendingByCorrelationId.get(event.correlationId);
+                        pendingByCorrelationId.delete(event.correlationId);
+                    }
+                    else {
+                        const queue = pendingByName.get(event.name);
+                        call = queue?.shift();
+                    }
+                    if (!call)
+                        break;
+                    const timestamp = cursor.next(event.timestamp);
+                    call.endTimeUnixNano = timestamp;
+                    call.events = [
+                        {
+                            timeUnixNano: timestamp,
+                            name: 'tool_result',
+                            attributes: {
+                                'tool.result': truncate(event.content),
+                                'tool.result.is_error': event.isError ?? false,
+                            },
+                        },
+                    ];
+                    call.status = event.isError ? { code: 'ERROR' } : { code: 'OK' };
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+        const usage = findTerminalUsage(rawText);
+        if (usage && agentTurns.length > 0) {
+            const last = agentTurns[agentTurns.length - 1];
+            last.attributes['gen_ai.usage.input_tokens'] = usage.inputTokens;
+            last.attributes['gen_ai.usage.output_tokens'] = usage.outputTokens;
+        }
+        return spans;
+    }
+}

package/node_modules/@jinn-network/core/dist/trajectory/transcript-to-spans/index.d.ts

@@ -0,0 +1,4 @@
+export * from './attrs.js';
+export * from './claude-code-stream-json.js';
+export * from './codex-exec-json.js';
+export * from './types.js';

package/node_modules/@jinn-network/core/dist/trajectory/transcript-to-spans/index.js

@@ -0,0 +1,4 @@
+export * from './attrs.js';
+export * from './claude-code-stream-json.js';
+export * from './codex-exec-json.js';
+export * from './types.js';

package/node_modules/@jinn-network/core/dist/trajectory/transcript-to-spans/types.d.ts

@@ -0,0 +1,18 @@
+import type { Span } from '../schema.js';
+/** A canonical typed trajectory span before collector-assigned ids and chaining. */
+export type TranscriptSpanInput = Omit<Span, 'traceId' | 'spanId' | 'parentSpanId'> & {
+    parentSpanId?: string | null;
+};
+/**
+ * Converts a native harness transcript to canonical typed trajectory spans.
+ * File parsing always degrades to an empty list. Parsers that can safely
+ * consume in-memory snapshot bytes expose the same implementation via
+ * `parseText`.
+ */
+export interface TranscriptSpanParser {
+    readonly sourceFormat: string;
+    readonly parserName: string;
+    readonly parserVersion: string;
+    parse(transcriptPath: string): Promise<TranscriptSpanInput[]>;
+    parseText?(rawText: string): TranscriptSpanInput[];
+}

package/node_modules/@jinn-network/core/dist/trajectory/transcript-to-spans/types.js

@@ -0,0 +1 @@
+export {};

package/node_modules/@jinn-network/core/dist/window.d.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod/v3';
+export declare const WindowSchema: z.ZodObject<{
+    startTs: z.ZodNumber;
+    endTs: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    startTs: number;
+    endTs: number;
+}, {
+    startTs: number;
+    endTs: number;
+}>;
+export type Window = z.infer<typeof WindowSchema>;

package/node_modules/@jinn-network/core/dist/window.js

@@ -0,0 +1,5 @@
+import { z } from 'zod/v3';
+export const WindowSchema = z.object({
+    startTs: z.number().int(),
+    endTs: z.number().int(),
+});

package/node_modules/@jinn-network/core/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@jinn-network/core",
+  "version": "0.1.0",
+  "description": "Domain core for Jinn — evidence/contribution stores, scrub, trajectory parsing, and corpus reads. Independent of client/src.",
+  "type": "module",
+  "packageManager": "yarn@4.13.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Jinn-Network/mono.git",
+    "directory": "packages/core"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./corpus-read": {
+      "import": "./dist/corpus-read/index.js",
+      "types": "./dist/corpus-read/index.d.ts"
+    },
+    "./scrub": {
+      "import": "./dist/scrub/index.js",
+      "types": "./dist/scrub/index.d.ts"
+    },
+    "./trajectory": {
+      "import": "./dist/trajectory/index.js",
+      "types": "./dist/trajectory/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run"
+  },
+  "peerDependencies": {
+    "vitest": "^4.1.8"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.0",
+    "@types/node": "^26.1.0",
+    "typescript": "^5.4.0",
+    "vitest": "^4.1.8"
+  },
+  "resolutions": {
+    "@jinn-network/plugin": "portal:../plugin"
+  }
+}

package/node_modules/@jinn-network/plugin/dist/eligibility.d.ts

@@ -0,0 +1,12 @@
+/** Cheap eligibility candidate-verdict (architecture §5). Pure over the
+ *  SessionOutcome facts the core already holds. Authoritative validation
+ *  (Docker F2P/P2P, resolvable repo@commit) stays sidecar-side. */
+import type { EligibilityVerdict } from './schemas/eligibility-verdict.js';
+export interface EligibilityInputs {
+    status: 'completed' | 'failed' | 'abandoned';
+    verifiabilityTier: 'user-accepted' | 'tests-passed' | 'evaluator-verified';
+    retentionPolicy: 'local-private' | 'contribution-eligible';
+    publicRepo?: boolean;
+    acceptedDiff?: boolean;
+}
+export declare function deriveEligibility(input: EligibilityInputs, checkedAt: string): EligibilityVerdict;

package/node_modules/@jinn-network/plugin/dist/eligibility.js

@@ -0,0 +1,12 @@
+export function deriveEligibility(input, checkedAt) {
+    if (input.status !== 'completed') {
+        return { eligible: false, reason: 'outcome not completed', checkedAt };
+    }
+    if (input.retentionPolicy !== 'contribution-eligible') {
+        return { eligible: false, reason: 'retention is local-private', checkedAt };
+    }
+    if (!input.acceptedDiff && !input.publicRepo) {
+        return { eligible: false, reason: 'no accepted diff signal', checkedAt };
+    }
+    return { eligible: true, reason: 'completed with accepted-diff/public-repo signal', checkedAt };
+}

package/node_modules/@jinn-network/plugin/dist/history.d.ts

@@ -0,0 +1,35 @@
+/** Derived history + explain views (product design §4.5). Owns no facts —
+ *  recomputed from Evidence + Contribution + LocalLearning on every call, so
+ *  deleting any cache leaves output identical (there is no cache). */
+import { type ContributionPort } from './ports/contribution-port.js';
+import type { EvidencePort } from './ports/evidence-port.js';
+import type { LocalLearningPort } from './ports/local-learning-port.js';
+import type { EligibilityVerdict } from './schemas/eligibility-verdict.js';
+import type { HistoryEntry } from './schemas/history-entry.js';
+export interface HistoryDeps {
+    evidence: EvidencePort;
+    contribution: ContributionPort;
+    localLearning: LocalLearningPort;
+}
+export interface HistoryResult {
+    entries: HistoryEntry[];
+    degraded: boolean;
+    unavailable: boolean;
+    reason?: string;
+}
+export interface SessionExplanation {
+    sessionRef: string;
+    found: boolean;
+    searchedTerms: string[];
+    providedRefs: string[];
+    captureStatus: 'captured' | 'not-captured';
+    eligibility: EligibilityVerdict | null;
+    contributionState: {
+        status: HistoryEntry['contributionState']['status'];
+        anchorRef?: string;
+    };
+    degraded: boolean;
+    reason?: string;
+}
+export declare function foldHistory(deps: HistoryDeps): Promise<HistoryResult>;
+export declare function foldExplain(sessionRef: string, deps: HistoryDeps): Promise<SessionExplanation>;

package/node_modules/@jinn-network/plugin/dist/history.js

@@ -0,0 +1,140 @@
+/** Derived history + explain views (product design §4.5). Owns no facts —
+ *  recomputed from Evidence + Contribution + LocalLearning on every call, so
+ *  deleting any cache leaves output identical (there is no cache). */
+import { deriveContributionStatus, } from './ports/contribution-port.js';
+import { unwrap } from './outcome.js';
+/** Fail-open list unwrap that records a labelled reason on non-ok reads. */
+function collect(res, label, fallback, reasons) {
+    const { value, reason } = unwrap(res, fallback);
+    if (reason !== undefined)
+        reasons.push(`${label}: ${reason}`);
+    return value;
+}
+function ledgerByEpisode(ledger) {
+    const map = new Map();
+    for (const row of ledger)
+        map.set(row.sourceId, row);
+    return map;
+}
+function contributionState(row, available = true) {
+    if (!available)
+        return { status: 'unavailable' };
+    if (!row)
+        return { status: 'none' };
+    const anchorRef = row.publicationRef ?? row.mintRef;
+    return {
+        status: deriveContributionStatus(row),
+        ...(anchorRef !== undefined ? { anchorRef } : {}),
+    };
+}
+/**
+ * New episodes persist the authoritative completion verdict. Historical v1
+ * records omit it, so reads stay backward compatible and honestly indeterminate
+ * rather than silently manufacturing a verdict from incomplete inputs.
+ */
+function episodeEligibility(ep) {
+    return ep.eligibility ?? null;
+}
+/**
+ * Canonical searched/provided activity from the new fields, falling back to
+ * the legacy surfaced/fetched refs for episodes captured before the rescope
+ * (rescope §3.6). An episode is "legacy" here when both new fields are empty
+ * AND at least one legacy field is not — a genuinely new episode with a
+ * nothing-found result has both sides empty, so the fallback is a no-op for it.
+ * Reads defensively (`?? []`): an `EvidencePort` is not required to
+ * schema-validate on read (the in-memory test double does not), so a record
+ * older than any given field must not crash the fold.
+ */
+function canonicalKnowledgeActivity(activity) {
+    if (!activity)
+        return { searchedTerms: [], providedRefs: [] };
+    const searchedTerms = activity.searchedTerms ?? [];
+    const providedRefs = activity.providedRefs ?? [];
+    const surfacedRefs = activity.surfacedRefs ?? [];
+    const fetchedRefs = activity.fetchedRefs ?? [];
+    const installedSkillRefs = activity.installedSkillRefs ?? [];
+    const isLegacy = searchedTerms.length === 0
+        && providedRefs.length === 0
+        && (surfacedRefs.length > 0 || fetchedRefs.length > 0 || installedSkillRefs.length > 0);
+    return isLegacy
+        ? { searchedTerms: surfacedRefs, providedRefs: fetchedRefs }
+        : { searchedTerms, providedRefs };
+}
+function knowledgeCounts(activity) {
+    const canonical = canonicalKnowledgeActivity(activity);
+    return { surfaced: canonical.searchedTerms.length, used: canonical.providedRefs.length };
+}
+function skillsBySession(skills) {
+    const bySession = new Map();
+    for (const skill of skills) {
+        for (const sessionId of skill.sourceSessionIds) {
+            const rows = bySession.get(sessionId) ?? [];
+            if (!rows.some((row) => row.ref === skill.ref && row.state === skill.state)) {
+                rows.push({ ref: skill.ref, state: skill.state });
+            }
+            bySession.set(sessionId, rows);
+        }
+    }
+    return bySession;
+}
+export async function foldHistory(deps) {
+    const reasons = [];
+    const episodesResult = await deps.evidence.list();
+    const episodes = collect(episodesResult, 'evidence', [], reasons);
+    const ledgerResult = await deps.contribution.ledger();
+    const ledger = collect(ledgerResult, 'contribution', [], reasons);
+    const skillsResult = deps.localLearning.skills
+        ? await deps.localLearning.skills()
+        : { status: 'unavailable', reason: 'skill provenance is unavailable' };
+    const skills = collect(skillsResult, 'localLearning', [], reasons);
+    const byEpisode = ledgerByEpisode(ledger);
+    const bySession = skillsBySession(skills);
+    const contributionAvailable = ledgerResult.status !== 'unavailable';
+    const skillsAvailable = skillsResult.status !== 'unavailable';
+    const entries = [...episodes]
+        .filter((ep) => ep.session.kind !== 'host-internal')
+        .sort((a, b) => b.session.capturedAt.localeCompare(a.session.capturedAt))
+        .map((ep) => {
+        const counts = knowledgeCounts(ep.activity);
+        return {
+            sessionId: ep.session.sessionId,
+            capturedAt: ep.session.capturedAt,
+            taskSummary: ep.task.summary,
+            knowledgeSurfaced: ep.activity ? counts.surfaced : null,
+            knowledgeUsed: ep.activity ? counts.used : null,
+            captureStatus: 'captured',
+            eligibility: episodeEligibility(ep),
+            contributionState: contributionState(byEpisode.get(ep.episodeId), contributionAvailable),
+            distilledSkills: skillsAvailable ? bySession.get(ep.session.sessionId) ?? [] : null,
+        };
+    });
+    const legacyFactsUnavailable = episodes.some((ep) => !ep.activity || !ep.eligibility);
+    if (legacyFactsUnavailable)
+        reasons.push('one or more episodes predate activity or eligibility facts');
+    const evidenceUnavailable = episodesResult.status === 'unavailable';
+    return reasons.length > 0
+        ? { entries, degraded: true, unavailable: evidenceUnavailable, reason: reasons.join('; ') }
+        : { entries, degraded: false, unavailable: false };
+}
+export async function foldExplain(sessionRef, deps) {
+    const reasons = [];
+    const episodes = collect(await deps.evidence.list(), 'evidence', [], reasons);
+    const ledgerResult = await deps.contribution.ledger();
+    const ledger = collect(ledgerResult, 'contribution', [], reasons);
+    const episode = episodes.find((ep) => ep.session.sessionId === sessionRef);
+    const contribution = episode
+        ? contributionState(ledger.find((row) => row.sourceId === episode.episodeId), ledgerResult.status !== 'unavailable')
+        : contributionState(undefined, ledgerResult.status !== 'unavailable');
+    const activity = canonicalKnowledgeActivity(episode?.activity);
+    return {
+        sessionRef,
+        found: Boolean(episode),
+        searchedTerms: activity.searchedTerms,
+        providedRefs: activity.providedRefs,
+        captureStatus: episode ? 'captured' : 'not-captured',
+        eligibility: episode ? episodeEligibility(episode) : null,
+        contributionState: contribution,
+        degraded: reasons.length > 0,
+        ...(reasons.length > 0 ? { reason: reasons.join('; ') } : {}),
+    };
+}

package/node_modules/@jinn-network/plugin/dist/index.d.ts

@@ -0,0 +1,32 @@
+export type { PortResult } from './outcome.js';
+export { ok, degraded, unavailable, valueOr, unwrap } from './outcome.js';
+export { EPISODE_SCHEMA_VERSION, EpisodeV1Schema, EpisodeV1WriteSchema, SessionActivityFactsSchema, SessionActivityFactsWriteSchema, VERIFICATION_STRENGTHS, VerificationStrengthSchema, } from './schemas/episode.js';
+export type { EpisodeV1, EpisodeV1Write, SessionActivityFacts, VerificationStrength, } from './schemas/episode.js';
+export { CONTRIBUTION_CANDIDATE_SCHEMA_VERSION, ContributionCandidateV1ProjectionSchema, ContributionCandidateV1Schema, } from './schemas/contribution-candidate.js';
+export type { ContributionCandidateV1 } from './schemas/contribution-candidate.js';
+export { KnowledgeHitSchema } from './schemas/knowledge-hit.js';
+export type { KnowledgeHit } from './schemas/knowledge-hit.js';
+export { EligibilityVerdictSchema } from './schemas/eligibility-verdict.js';
+export type { EligibilityVerdict } from './schemas/eligibility-verdict.js';
+export { SessionSummarySchema } from './schemas/session-summary.js';
+export type { SessionSummary } from './schemas/session-summary.js';
+export { HistoryEntrySchema } from './schemas/history-entry.js';
+export type { HistoryEntry } from './schemas/history-entry.js';
+export type { CorpusPort, CorpusRecord, CorpusRecordStep } from './ports/corpus-port.js';
+export type { EvidencePort, EvidenceListQuery, EvidenceRetentionPolicy } from './ports/evidence-port.js';
+export { deriveContributionStatus } from './ports/contribution-port.js';
+export type { ContributionPort, ContributionLedgerEntry, ContributionLocalState, ContributionPublicationState, ContributionState, ContributionStatus, ContributionStatusSnapshot, } from './ports/contribution-port.js';
+export type { LocalLearningPort, LocalLearningRun, LocalLearningSkill, } from './ports/local-learning-port.js';
+export type { SkillsPort, SkillRecord } from './ports/skills-port.js';
+export { createJinnPlugin, JINN_PLUGIN_CONTRACT_VERSION, PluginSession } from './plugin.js';
+export type { CompleteSessionEligibilityInputs, CompleteSessionInput, JinnPlugin, JinnPluginDeps, SessionMeta, FirstTurnPickupResult, ToolCallEvent, SessionOutcome, SessionEndResult, ContributionCompletionReceipt, ContributionPreview, } from './plugin.js';
+export { PickupConfigSchema, DEFAULT_PICKUP_CONFIG, parsePickupConfig, TIER_ORDER } from './schemas/pickup-config.js';
+export type { PickupConfig, Tier } from './schemas/pickup-config.js';
+export { deriveRepositorySearchTerms, discriminatingTerms, deriveSearchTerms, classifyPayload, dedupeKnowledgeHits, scoreKnowledgeHit, selectKnowledgeHits, rankKnowledgeHits, MAX_SELECTED_PACKETS, } from './pickup.js';
+export { KNOWLEDGE_PACKET_SCHEMA_VERSION, KnowledgePacketSchema, KnowledgePacketExcerptSchema, DEFAULT_PACKET_CHAR_BUDGET, projectKnowledgePacket, truncateLineBoundary, } from './schemas/knowledge-packet.js';
+export type { KnowledgePacket, KnowledgePacketExcerpt, KnowledgePacketBudget, } from './schemas/knowledge-packet.js';
+export { RETRIEVAL_VISIBLE_TAG, hasRetrievalMark } from './visibility.js';
+export { deriveEligibility } from './eligibility.js';
+export type { EligibilityInputs } from './eligibility.js';
+export { foldHistory, foldExplain } from './history.js';
+export type { HistoryResult, SessionExplanation, HistoryDeps } from './history.js';

package/node_modules/@jinn-network/plugin/dist/index.js

@@ -0,0 +1,15 @@
+export { ok, degraded, unavailable, valueOr, unwrap } from './outcome.js';
+export { EPISODE_SCHEMA_VERSION, EpisodeV1Schema, EpisodeV1WriteSchema, SessionActivityFactsSchema, SessionActivityFactsWriteSchema, VERIFICATION_STRENGTHS, VerificationStrengthSchema, } from './schemas/episode.js';
+export { CONTRIBUTION_CANDIDATE_SCHEMA_VERSION, ContributionCandidateV1ProjectionSchema, ContributionCandidateV1Schema, } from './schemas/contribution-candidate.js';
+export { KnowledgeHitSchema } from './schemas/knowledge-hit.js';
+export { EligibilityVerdictSchema } from './schemas/eligibility-verdict.js';
+export { SessionSummarySchema } from './schemas/session-summary.js';
+export { HistoryEntrySchema } from './schemas/history-entry.js';
+export { deriveContributionStatus } from './ports/contribution-port.js';
+export { createJinnPlugin, JINN_PLUGIN_CONTRACT_VERSION, PluginSession } from './plugin.js';
+export { PickupConfigSchema, DEFAULT_PICKUP_CONFIG, parsePickupConfig, TIER_ORDER } from './schemas/pickup-config.js';
+export { deriveRepositorySearchTerms, discriminatingTerms, deriveSearchTerms, classifyPayload, dedupeKnowledgeHits, scoreKnowledgeHit, selectKnowledgeHits, rankKnowledgeHits, MAX_SELECTED_PACKETS, } from './pickup.js';
+export { KNOWLEDGE_PACKET_SCHEMA_VERSION, KnowledgePacketSchema, KnowledgePacketExcerptSchema, DEFAULT_PACKET_CHAR_BUDGET, projectKnowledgePacket, truncateLineBoundary, } from './schemas/knowledge-packet.js';
+export { RETRIEVAL_VISIBLE_TAG, hasRetrievalMark } from './visibility.js';
+export { deriveEligibility } from './eligibility.js';
+export { foldHistory, foldExplain } from './history.js';

package/node_modules/@jinn-network/plugin/dist/outcome.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Port result envelope (architecture spec §4). Adapters may throw; ports
+ * never do — every port method resolves a PortResult so a failure surfaces
+ * as a typed outcome, never a crash into the host session.
+ */
+export type PortResult<T> = {
+    status: 'ok';
+    value: T;
+} | {
+    status: 'degraded';
+    reason: string;
+    value?: T;
+} | {
+    status: 'unavailable';
+    reason: string;
+};
+export declare function ok<T>(value: T): PortResult<T>;
+export declare function degraded<T>(reason: string, value?: T): PortResult<T>;
+export declare function unavailable<T = never>(reason: string): PortResult<T>;
+/** Fail-open value access: ok → value; degraded → value ?? fallback; unavailable → fallback. */
+export declare function valueOr<T>(res: PortResult<T>, fallback: T): T;
+/** Like valueOr, but also surfaces the failure reason so callers can collect it. */
+export declare function unwrap<T>(res: PortResult<T>, fallback: T): {
+    value: T;
+    reason?: string;
+};