@gyoungwe/pi-evidence 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,23 @@
-# Temporary Holding Version
+# @gyoungwe/pi-evidence
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Portable evidence contracts for native Pi and Drone Desktop. The package is a
+read-only boundary: it validates content-addressed artifact manifests,
+provenance and digest declarations, immutable checkpoint and branch metadata,
+evidence capsules, and replay/import proofs.
+
+The package does not read files, write a ledger, create workspaces, execute a
+workflow, or inherit execution authorization. A host supplies bytes and
+persists validated records in its composition root. Capsule blobs are passed as
+base64 strings or `Uint8Array` values, so a host can choose its own storage
+policy. Absolute paths, traversal, credential names, `.pi`/`.drone` state and
+other private state labels are rejected at the contract boundary.
+
+The native Pi extension registers three read-only tools:
+
+- `evidence_validate_manifest`
+- `evidence_validate_capsule`
+- `evidence_verify_replay`
+
+`npm run check` runs the typecheck, deterministic self-contained build,
+registration tests and a clean tarball install smoke. It does not publish the
+package or call a model.

package/build-manifest.json

@@ -0,0 +1,8 @@
+{
+	"version": 1,
+	"generator": "packages/pi-evidence/scripts/build.mjs",
+	"inputsSha256": "d789c68b05f48ae651bfcd4a717b044ef0cdb6cb03a9cb60be0d83c80e52781e",
+	"outputs": {
+		"dist/index.mjs": "0e8bc22875efda4e4a2ff4641c4e04424089c37cef60c99ac5a5049a2b56e85e"
+	}
+}

package/dist/index.mjs

@@ -0,0 +1,598 @@
+// @ts-nocheck
+// src/digest.ts
+import { createHash } from "node:crypto";
+function stableJson(value) {
+  if (value === null || typeof value !== "object") {
+    const encoded = JSON.stringify(value);
+    return encoded === void 0 ? "null" : encoded;
+  }
+  if (Array.isArray(value)) return `[${value.map((item) => stableJson(item)).join(",")}]`;
+  const object = value;
+  return `{${Object.keys(object).filter((key) => object[key] !== void 0).sort().map((key) => `${JSON.stringify(key)}:${stableJson(object[key])}`).join(",")}}`;
+}
+function canonicalJson(value) {
+  return `${stableJson(value)}
+`;
+}
+function sha256Hex(value) {
+  return createHash("sha256").update(value).digest("hex");
+}
+function digestJson(value) {
+  return sha256Hex(canonicalJson(value));
+}
+function isSha256(value) {
+  return typeof value === "string" && /^[a-f0-9]{64}$/iu.test(value);
+}
+
+// src/artifacts.ts
+var EVIDENCE_CAPSULE_LIMIT = 64 * 1024 * 1024;
+var PRIVATE_PATH_PART = /^(?:\.env(?:\.|$)|auth\.json$|credentials?(?:\.|$)|secrets?(?:\.|$)|tokens?(?:\.|$)|password(?:\.|$)|\.ssh$|\.git$|\.pi$|\.drone$|userData$|sessions?$)/iu;
+function isSafeEvidencePath(path) {
+  if (typeof path !== "string" || !path || path.includes("\0") || path.includes("\\")) return false;
+  if (path.startsWith("/") || path.startsWith("~") || /^[A-Za-z]:/.test(path)) return false;
+  const parts = path.split("/");
+  return parts.every(
+    (part) => part.length > 0 && part !== "." && part !== ".." && !PRIVATE_PATH_PART.test(part)
+  );
+}
+function isSafeBranchId(value) {
+  return typeof value === "string" && /^[A-Za-z0-9][A-Za-z0-9_-]{0,100}$/.test(value);
+}
+function bytesOf(entry) {
+  return entry.bytes ?? entry.size ?? 0;
+}
+function normalizeEntry(entry) {
+  return {
+    artifactId: entry.artifactId ?? "",
+    versionId: entry.versionId ?? "",
+    path: entry.path,
+    sha256: entry.sha256 ?? "",
+    bytes: bytesOf(entry),
+    role: entry.role ?? "output",
+    ...entry.accessLevel ? { accessLevel: entry.accessLevel } : {},
+    parentVersionIds: [...entry.parentVersionIds ?? []],
+    ...entry.producedByJobId ? { producedByJobId: entry.producedByJobId } : {}
+  };
+}
+function sourceEntries(manifest) {
+  if (Array.isArray(manifest)) return manifest;
+  return manifest.entries;
+}
+function validateArtifactManifest(manifest, options = {}) {
+  const source = sourceEntries(manifest);
+  const errors = [];
+  const objectManifest = Array.isArray(manifest) ? void 0 : manifest;
+  if (objectManifest && objectManifest.version !== 1) errors.push("Unsupported artifact manifest version");
+  const entries = source.map(normalizeEntry);
+  const verifications = [];
+  const paths = /* @__PURE__ */ new Set();
+  const versions = /* @__PURE__ */ new Set();
+  const expectedByPath = new Map((options.expected ?? source).map((entry) => [entry.path, entry]));
+  let totalBytes = 0;
+  for (const entry of entries) {
+    const path = entry.path;
+    const pathKey = path.toLocaleLowerCase("en-US");
+    const bytes = entry.bytes;
+    totalBytes += Number.isFinite(bytes) ? bytes : 0;
+    let reason;
+    if (!isSafeEvidencePath(path)) {
+      reason = path.startsWith("/") || path.startsWith("~") || /^[A-Za-z]:/.test(path) ? "private-path" : "invalid-path";
+      errors.push(`Unsafe evidence path: ${path}`);
+    }
+    if (paths.has(pathKey) || [...paths].some((known) => known.startsWith(`${pathKey}/`) || pathKey.startsWith(`${known}/`))) {
+      reason = "invalid-path";
+      errors.push(`Duplicate or conflicting evidence path: ${path}`);
+    }
+    paths.add(pathKey);
+    if (options.requireIdentity && (!entry.artifactId || !entry.versionId || versions.has(entry.versionId))) {
+      errors.push(`Invalid or duplicate artifact identity: ${path}`);
+    }
+    versions.add(entry.versionId);
+    if (!Number.isSafeInteger(bytes) || bytes < 0) {
+      reason = "size-mismatch";
+      errors.push(`Invalid artifact size: ${path}`);
+    }
+    if (!isSha256(entry.sha256)) {
+      reason = "checksum-mismatch";
+      errors.push(`Invalid sha256: ${path}`);
+    }
+    if (!Array.isArray(entry.parentVersionIds)) errors.push(`Invalid parent version list: ${path}`);
+    if (!["input", "output", "code", "environment", "review"].includes(entry.role)) {
+      errors.push(`Invalid artifact role: ${path}`);
+    }
+    const expected = expectedByPath.get(path);
+    if (expected?.bytes !== void 0 && bytes > expected.bytes)
+      errors.push(`Artifact exceeds expected size: ${path}`);
+    verifications.push({ path, expectedSha256: entry.sha256, ok: !reason, ...reason ? { reason } : {} });
+  }
+  if (options.maxTotalBytes !== void 0 && totalBytes > options.maxTotalBytes)
+    errors.push(`Artifacts exceed ${options.maxTotalBytes} bytes`);
+  if (totalBytes > EVIDENCE_CAPSULE_LIMIT) errors.push("Evidence exceeds capsule limit");
+  if (objectManifest && objectManifest.totalBytes !== void 0 && objectManifest.totalBytes !== totalBytes)
+    errors.push("Artifact manifest totalBytes mismatch");
+  const result2 = verifications;
+  Object.assign(result2, { valid: errors.length === 0, errors, entries, totalBytes });
+  return result2;
+}
+function assertValidArtifactManifest(manifest, options = {}) {
+  const validation = validateArtifactManifest(manifest, {
+    ...options,
+    requireIdentity: options.requireIdentity ?? true
+  });
+  if (!validation.valid) throw new Error(`Invalid artifact manifest: ${validation.errors.join("; ")}`);
+  const entries = [...validation.entries].sort((a, b) => a.path.localeCompare(b.path));
+  const normalized = { version: 1, entries, totalBytes: validation.totalBytes };
+  return normalized;
+}
+function artifactManifestDigest(manifest) {
+  const normalized = assertValidArtifactManifest(manifest, { requireIdentity: false });
+  return digestJson(normalized);
+}
+var isSafeArtifactPath = isSafeEvidencePath;
+function artifactManifestBytes(manifest) {
+  return manifest.entries.reduce((total, entry) => total + entry.bytes, 0);
+}
+function withinArtifactLimit(manifest, maxBytes) {
+  return Number.isFinite(maxBytes) && maxBytes >= 0 && artifactManifestBytes(manifest) <= maxBytes;
+}
+function validateArtifactEntry(entry) {
+  const result2 = validateArtifactManifest([entry]);
+  return result2[0]?.ok ? void 0 : result2[0]?.reason ?? "checksum-mismatch";
+}
+function artifactDigest(bytes) {
+  return sha256Hex(bytes);
+}
+function artifactFromBytes(input) {
+  if (!input.artifactId || !input.versionId || !isSafeEvidencePath(input.path))
+    throw new Error("Artifact identity or path is invalid");
+  const bytes = typeof input.bytes === "string" ? new TextEncoder().encode(input.bytes) : input.bytes;
+  return {
+    artifactId: input.artifactId,
+    versionId: input.versionId,
+    path: input.path,
+    sha256: artifactDigest(bytes),
+    bytes: bytes.byteLength,
+    role: input.role,
+    ...input.accessLevel ? { accessLevel: input.accessLevel } : {},
+    parentVersionIds: [...input.parentVersionIds ?? []],
+    ...input.producedByJobId ? { producedByJobId: input.producedByJobId } : {}
+  };
+}
+
+// src/provenance.ts
+function validateProvenance(value) {
+  if (value.schemaVersion !== 1 || !Array.isArray(value.artifacts))
+    throw new Error("Invalid evidence provenance");
+  assertValidArtifactManifest({ version: 1, entries: value.artifacts }, { requireIdentity: true });
+  for (const [label, digest] of [
+    ["workflowDigest", value.workflowDigest],
+    ["methodDigest", value.methodDigest],
+    ["toolContractDigest", value.toolContractDigest],
+    ["containerDigest", value.containerDigest],
+    ["specSha256", value.specSha256]
+  ]) {
+    if (digest !== void 0 && !isSha256(digest)) throw new Error(`Invalid ${label}`);
+  }
+  if (value.sourceRefs?.some(
+    (ref) => typeof ref !== "string" || !ref.trim() || ref.startsWith("/") || ref.startsWith("~") || /^[A-Za-z]:[\\/]/.test(ref) || /(?:^|[/\\])(?:\.pi|\.drone|\.git|\.ssh|auth\.json|credentials?)(?:[/\\]|$)/iu.test(ref)
+  ))
+    throw new Error("Invalid provenance source reference");
+}
+function provenanceDigest(value) {
+  validateProvenance(value);
+  return digestJson({
+    ...value,
+    artifacts: [...value.artifacts].sort((a, b) => a.path.localeCompare(b.path))
+  });
+}
+function workflowDigest(value) {
+  return digestJson(value);
+}
+function methodDigest(value) {
+  return digestJson(value);
+}
+function toolContractDigest(value) {
+  return digestJson(value);
+}
+function containerDigest(value) {
+  return digestJson(value);
+}
+function createEvidenceProvenance(input) {
+  const value = {
+    schemaVersion: 1,
+    ...input,
+    artifacts: [...input.artifacts].sort((a, b) => a.path.localeCompare(b.path))
+  };
+  validateProvenance(value);
+  return value;
+}
+
+// src/checkpoints.ts
+function checkpointBody(value) {
+  const { lineage: _lineage, analysis, ...rest } = value;
+  const { provenance, ...analysisRest } = analysis;
+  const checkpointProvenance = provenance ? (({ lineage: _lineage2, ...withoutLineage }) => withoutLineage)(
+    provenance
+  ) : void 0;
+  const contentAnalysis = {
+    version: analysisRest.version,
+    id: analysisRest.id,
+    question: analysisRest.question,
+    assay: analysisRest.assay,
+    mode: analysisRest.mode,
+    ...analysisRest.stage ? { stage: analysisRest.stage } : {},
+    ...analysisRest.status ? { status: analysisRest.status } : {},
+    ...analysisRest.capabilities ? { capabilities: [...analysisRest.capabilities] } : {},
+    ...analysisRest.adapter ? { adapter: { ...analysisRest.adapter } } : {},
+    ...checkpointProvenance ? { provenance: checkpointProvenance } : {},
+    ...analysisRest.review ? { review: { ...analysisRest.review, limitations: [...analysisRest.review.limitations] } } : {},
+    ...analysisRest.publicationRequested !== void 0 ? { publicationRequested: analysisRest.publicationRequested } : {},
+    ...analysisRest.events ? { events: analysisRest.events.map((event) => ({ ...event })) } : {}
+  };
+  const files = [...value.files].sort((left, right) => left.artifact.path.localeCompare(right.artifact.path));
+  return { ...rest, files, analysis: contentAnalysis };
+}
+function checkpointId(value) {
+  return digestJson(checkpointBody(value));
+}
+function validateAnalysis(value) {
+  if (value.version !== 1 || typeof value.id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]*$/.test(value.id) || typeof value.question !== "string" || !value.question.trim() || typeof value.assay !== "string" || !value.assay.trim() || value.mode !== "exploratory" && value.mode !== "inferential")
+    throw new Error("Invalid evidence analysis snapshot");
+  const rawAnalysis = value;
+  if ("branchOf" in rawAnalysis || "workspace" in rawAnalysis)
+    throw new Error("Evidence analysis snapshot cannot contain host workspace state");
+  if (value.provenance) validateProvenance(value.provenance);
+  if (value.events?.some((event) => typeof event.at !== "string" || typeof event.type !== "string"))
+    throw new Error("Invalid analysis event");
+}
+function validateCheckpoint(checkpoint) {
+  const { id, ...body } = checkpoint;
+  if (checkpoint.schemaVersion !== 1 || id !== checkpointId(body))
+    throw new Error("Checkpoint manifest checksum mismatch");
+  validateAnalysis(checkpoint.analysis);
+  if (Number.isNaN(Date.parse(checkpoint.createdAt))) throw new Error("Invalid checkpoint timestamp");
+  if (checkpoint.lineage && (!checkpoint.lineage.eventId || checkpoint.lineage.eventId.includes("/")))
+    throw new Error("Invalid checkpoint lineage");
+  if (checkpoint.environmentFingerprint !== void 0 && (typeof checkpoint.environmentFingerprint !== "string" || checkpoint.environmentFingerprint.length > 512))
+    throw new Error("Invalid environment fingerprint");
+  if (!Array.isArray(checkpoint.files) || checkpoint.files.length === 0 || checkpoint.files.length > 1e4)
+    throw new Error("Invalid evidence files");
+  const validation = assertValidArtifactManifest(
+    { version: 1, entries: checkpoint.files.map((file) => file.artifact) },
+    { requireIdentity: true }
+  );
+  if ((validation.totalBytes ?? 0) > EVIDENCE_CAPSULE_LIMIT)
+    throw new Error("Evidence exceeds capsule limit");
+  const kinds = /* @__PURE__ */ new Set(["input", "output", "code", "environment", "review"]);
+  for (const file of checkpoint.files) {
+    if (!kinds.has(file.kind) || file.kind !== file.artifact.role)
+      throw new Error("Evidence file kind does not match artifact role");
+    if (!isSafeEvidencePath(file.artifact.path) || !isSha256(file.artifact.sha256))
+      throw new Error("Invalid frozen artifact");
+  }
+}
+function createCheckpoint(input) {
+  const body = {
+    schemaVersion: 1,
+    ...input,
+    files: [...input.files].sort((left, right) => left.artifact.path.localeCompare(right.artifact.path))
+  };
+  const checkpoint = { ...body, id: checkpointId(body) };
+  validateCheckpoint(checkpoint);
+  return checkpoint;
+}
+function createBranch(input) {
+  if (!isSafeBranchId(input.id)) throw new Error("Unsafe evidence branch id");
+  validateCheckpoint(input.checkpoint);
+  if (Number.isNaN(Date.parse(input.createdAt))) throw new Error("Invalid branch timestamp");
+  const branch = {
+    schemaVersion: 1,
+    id: input.id,
+    checkpointId: input.checkpoint.id,
+    sourceAnalysisId: input.checkpoint.analysis.id,
+    status: input.status ?? "preparing",
+    createdAt: input.createdAt
+  };
+  validateBranch(branch);
+  return branch;
+}
+function validateBranch(branch) {
+  if (branch.schemaVersion !== 1 || !isSafeBranchId(branch.id) || !isSha256(branch.checkpointId) || !branch.sourceAnalysisId || !["preparing", "ready", "failed"].includes(branch.status) || Number.isNaN(Date.parse(branch.createdAt)))
+    throw new Error("Invalid evidence branch");
+}
+function toEvidenceAnalysisSnapshot(context) {
+  return {
+    version: 1,
+    id: context.id,
+    question: context.question,
+    assay: context.assay,
+    mode: context.mode,
+    stage: context.stage,
+    status: context.status,
+    capabilities: context.capabilities ? [...context.capabilities] : [],
+    ...context.adapter ? { adapter: { ...context.adapter } } : {},
+    ...context.provenance ? { provenance: context.provenance } : {},
+    ...context.review ? {
+      review: {
+        approved: context.review.approved,
+        detail: context.review.detail,
+        limitations: [...context.review.limitations]
+      }
+    } : {},
+    publicationRequested: context.publicationRequested,
+    events: context.events ? context.events.map((event) => ({ ...event })) : []
+  };
+}
+
+// src/capsule.ts
+var CAPSULE_LIMIT = EVIDENCE_CAPSULE_LIMIT;
+var audienceRank = (value) => value === "public" ? 0 : value === "restricted" ? 1 : 2;
+function decodeBase64(value) {
+  if (!value || value.length > EVIDENCE_CAPSULE_LIMIT * 2 || !/^[A-Za-z0-9+/]*={0,2}$/.test(value))
+    throw new Error("Invalid or oversized capsule blob");
+  const data = Uint8Array.from(Buffer.from(value, "base64"));
+  if (Buffer.from(data).toString("base64") !== value) throw new Error("Invalid capsule base64");
+  return data;
+}
+function encodeBlob(value) {
+  return typeof value === "string" ? value : Buffer.from(value).toString("base64");
+}
+function eligibleFiles(capsule) {
+  const audience = capsule.publication?.audience ?? "private";
+  return capsule.checkpoint.files.filter((file) => audienceRank(file.artifact.accessLevel ?? "private") <= audienceRank(audience)).map((file) => file.artifact);
+}
+function validateCapsule(capsule) {
+  if (capsule.format !== "drone-evidence-capsule" || capsule.version !== 1)
+    throw new Error("Unsupported capsule version");
+  validateCheckpoint(capsule.checkpoint);
+  const audience = capsule.publication?.audience ?? "private";
+  if (!["public", "restricted", "private"].includes(audience))
+    throw new Error("Invalid capsule publication audience");
+  const omittedPaths = capsule.checkpoint.files.filter((file) => audienceRank(file.artifact.accessLevel ?? "private") > audienceRank(audience)).map((file) => file.artifact.path).sort();
+  if (capsule.publication && canonicalJson([...capsule.publication.omittedPaths].sort()) !== canonicalJson(omittedPaths))
+    throw new Error("Capsule publication omission list mismatch");
+  const expected = new Set(eligibleFiles(capsule).map((artifact) => artifact.sha256));
+  if (!capsule.blobs || typeof capsule.blobs !== "object") throw new Error("Missing capsule blobs");
+  for (const [hash, encoded] of Object.entries(capsule.blobs)) {
+    if (!isSha256(hash) || !expected.has(hash)) throw new Error("Unexpected capsule blob");
+    const data = decodeBase64(encoded);
+    const artifact = capsule.checkpoint.files.find((file) => file.artifact.sha256 === hash)?.artifact;
+    if (!artifact || data.byteLength !== artifact.bytes || sha256Hex(data) !== hash)
+      throw new Error("Capsule blob checksum mismatch");
+  }
+  for (const artifact of eligibleFiles(capsule))
+    if (typeof capsule.blobs[artifact.sha256] !== "string") throw new Error("Missing capsule blob");
+  if (Object.keys(capsule.blobs).length !== expected.size) throw new Error("Unexpected capsule blobs");
+}
+function createEvidenceCapsule(checkpoint, blobs, audience = "private") {
+  validateCheckpoint(checkpoint);
+  const omittedPaths = checkpoint.files.filter((file) => audienceRank(file.artifact.accessLevel ?? "private") > audienceRank(audience)).map((file) => file.artifact.path).sort();
+  const selected = {};
+  for (const artifact of checkpoint.files.map((file) => file.artifact)) {
+    if (audienceRank(artifact.accessLevel ?? "private") > audienceRank(audience)) continue;
+    const value = blobs[artifact.sha256];
+    if (value === void 0) throw new Error(`Missing blob for ${artifact.path}`);
+    const encoded = encodeBlob(value);
+    const bytes = decodeBase64(encoded);
+    if (bytes.byteLength !== artifact.bytes || sha256Hex(bytes) !== artifact.sha256)
+      throw new Error(`Blob does not match ${artifact.path}`);
+    selected[artifact.sha256] = encoded;
+  }
+  const capsule = {
+    format: "drone-evidence-capsule",
+    version: 1,
+    checkpoint,
+    blobs: selected,
+    ...audience === "private" ? {} : { publication: { audience, omittedPaths } }
+  };
+  validateCapsule(capsule);
+  return capsule;
+}
+function serializeCapsule(capsule) {
+  validateCapsule(capsule);
+  return canonicalJson(canonicalCapsule(capsule));
+}
+function canonicalCapsule(capsule) {
+  if (!capsule.publication) return capsule;
+  return {
+    ...capsule,
+    publication: {
+      ...capsule.publication,
+      omittedPaths: [...capsule.publication.omittedPaths].sort()
+    }
+  };
+}
+function parseCapsule(serialized) {
+  if (serialized.length > EVIDENCE_CAPSULE_LIMIT * 2) throw new Error("Capsule exceeds import limit");
+  let parsed;
+  try {
+    parsed = JSON.parse(serialized);
+  } catch {
+    throw new Error("Invalid evidence capsule JSON");
+  }
+  validateCapsule(parsed);
+  return parsed;
+}
+function validateCapsuleImport(serialized) {
+  const capsule = typeof serialized === "string" ? parseCapsule(serialized) : serialized;
+  validateCapsule(capsule);
+  return capsule.checkpoint;
+}
+function capsuleDigest(capsule) {
+  validateCapsule(capsule);
+  return digestJson(canonicalCapsule(capsule));
+}
+function capsuleBytes(capsule) {
+  return new TextEncoder().encode(serializeCapsule(capsule));
+}
+
+// src/replay.ts
+function outputFiles(checkpoint) {
+  return checkpoint.files.filter((file) => file.kind === "output").map((file) => file.artifact);
+}
+function validateOutput(value) {
+  if (!isSafeEvidencePath(value.path) || !Number.isSafeInteger(value.bytes) || value.bytes < 0 || !isSha256(value.sha256))
+    throw new Error(`Invalid replay output: ${value.path}`);
+}
+function verifyReplay(checkpoint, input) {
+  validateCheckpoint(checkpoint);
+  const seenOutputs = /* @__PURE__ */ new Set();
+  for (const output of input.outputs) {
+    validateOutput(output);
+    if (seenOutputs.has(output.path)) throw new Error(`Duplicate replay output: ${output.path}`);
+    seenOutputs.add(output.path);
+  }
+  const expected = outputFiles(checkpoint);
+  const actualByPath = new Map(input.outputs.map((output) => [output.path, output]));
+  const checks = expected.map((artifact) => {
+    const actual = actualByPath.get(artifact.path);
+    return {
+      path: artifact.path,
+      matched: !!actual && actual.bytes === artifact.bytes && actual.sha256.toLowerCase() === artifact.sha256.toLowerCase()
+    };
+  });
+  const expectedPaths = new Set(expected.map((artifact) => artifact.path));
+  const unexpected = input.outputs.some((output) => !expectedPaths.has(output.path));
+  const environmentMatched = checkpoint.environmentFingerprint !== void 0 && input.environmentFingerprint === checkpoint.environmentFingerprint;
+  const reproduced = environmentMatched && checks.length === expected.length && checks.every((check) => check.matched) && !unexpected;
+  return {
+    status: reproduced ? "reproduced" : "failed",
+    detail: reproduced ? "Exact output bytes and environment matched" : "Output or environment differs from frozen evidence",
+    outputChecks: checks,
+    environmentMatched
+  };
+}
+function createReplayReceipt(input) {
+  const verification = verifyReplay(input.checkpoint, {
+    environmentFingerprint: input.environmentFingerprint,
+    outputs: input.outputs
+  });
+  if (!input.id || !input.completedAt || Number.isNaN(Date.parse(input.completedAt)))
+    throw new Error("Invalid replay receipt identity");
+  return { ...verification, id: input.id, checkpointId: input.checkpoint.id, completedAt: input.completedAt };
+}
+function validateReplayReceipt(receipt) {
+  if (!receipt.id || !isSha256(receipt.checkpointId) || Number.isNaN(Date.parse(receipt.completedAt)) || receipt.status === "reproduced" && (!receipt.environmentMatched || receipt.outputChecks.some((check) => !check.matched)))
+    throw new Error("Invalid replay receipt");
+  const seenPaths = /* @__PURE__ */ new Set();
+  for (const check of receipt.outputChecks) {
+    if (!isSafeEvidencePath(check.path) || seenPaths.has(check.path))
+      throw new Error("Invalid replay output check path");
+    seenPaths.add(check.path);
+  }
+}
+var replayProof = verifyReplay;
+
+// src/index.ts
+function result(details) {
+  return { content: [{ type: "text", text: JSON.stringify(details, null, 2) }], details };
+}
+function readObject(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object`);
+  return value;
+}
+function registerPiEvidence(pi) {
+  pi.registerTool({
+    name: "evidence_validate_manifest",
+    label: "Evidence \xB7 validate manifest",
+    description: "Validate content-addressed artifact metadata without reading files or writing state.",
+    drone: { readOnly: true, recoverySafe: true, capabilities: ["evidence", "files"] },
+    parameters: { type: "object", properties: { manifest: { type: "object" } }, required: ["manifest"] },
+    async execute(_id, params) {
+      const input = readObject(params, "params");
+      return result(validateArtifactManifest(input.manifest, { requireIdentity: true }));
+    }
+  });
+  pi.registerTool({
+    name: "evidence_validate_capsule",
+    label: "Evidence \xB7 validate capsule",
+    description: "Validate an imported evidence capsule, omission list and every blob digest without importing it.",
+    drone: { readOnly: true, recoverySafe: true, capabilities: ["evidence", "files"] },
+    parameters: {
+      type: "object",
+      properties: { capsule: { type: "object" }, serialized: { type: "string" } }
+    },
+    async execute(_id, params) {
+      const input = readObject(params, "params");
+      const checkpoint = validateCapsuleImport(
+        input.serialized !== void 0 ? String(input.serialized) : input.capsule
+      );
+      return result({ valid: true, checkpointId: checkpoint.id, analysisId: checkpoint.analysis.id });
+    }
+  });
+  pi.registerTool({
+    name: "evidence_verify_replay",
+    label: "Evidence \xB7 verify replay",
+    description: "Compare host-provided output metadata and environment fingerprint with a frozen checkpoint.",
+    drone: { readOnly: true, recoverySafe: true, capabilities: ["evidence", "files"] },
+    parameters: {
+      type: "object",
+      properties: {
+        checkpoint: { type: "object" },
+        environmentFingerprint: { type: "string" },
+        outputs: { type: "array" }
+      },
+      required: ["checkpoint", "outputs"]
+    },
+    async execute(_id, params) {
+      const input = readObject(params, "params");
+      return result(
+        verifyReplay(input.checkpoint, {
+          environmentFingerprint: input.environmentFingerprint === void 0 ? void 0 : String(input.environmentFingerprint),
+          outputs: Array.isArray(input.outputs) ? input.outputs : []
+        })
+      );
+    }
+  });
+  return {
+    tools: ["evidence_validate_manifest", "evidence_validate_capsule", "evidence_verify_replay"]
+  };
+}
+var index_default = registerPiEvidence;
+export {
+  CAPSULE_LIMIT,
+  EVIDENCE_CAPSULE_LIMIT,
+  artifactDigest,
+  artifactFromBytes,
+  artifactManifestBytes,
+  artifactManifestDigest,
+  assertValidArtifactManifest,
+  canonicalJson,
+  capsuleBytes,
+  capsuleDigest,
+  checkpointId,
+  containerDigest,
+  createBranch,
+  createCheckpoint,
+  createEvidenceCapsule,
+  createEvidenceProvenance,
+  createReplayReceipt,
+  index_default as default,
+  digestJson,
+  isSafeArtifactPath,
+  isSafeBranchId,
+  isSafeEvidencePath,
+  isSha256,
+  methodDigest,
+  parseCapsule,
+  provenanceDigest,
+  registerPiEvidence,
+  replayProof,
+  serializeCapsule,
+  sha256Hex,
+  stableJson,
+  toEvidenceAnalysisSnapshot,
+  toolContractDigest,
+  validateArtifactEntry,
+  validateArtifactManifest,
+  validateBranch,
+  validateCapsule,
+  validateCapsuleImport,
+  validateCheckpoint,
+  validateProvenance,
+  validateReplayReceipt,
+  verifyReplay,
+  withinArtifactLimit,
+  workflowDigest
+};

package/package.json

@@ -1,6 +1,18 @@
 {
   "name": "@gyoungwe/pi-evidence",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Portable evidence manifests, provenance, checkpoints and replay proofs for native Pi",
+  "keywords": ["pi-package", "evidence", "provenance", "reproducibility"],
+  "license": "MIT",
+  "publishConfig": {"access": "public"},
+  "repository": {"type": "git", "url": "git+https://github.com/Gyoungwe/drone-plugins.git", "directory": "packages/pi-evidence"},
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "files": ["dist", "src", "package.json", "README.md", "build-manifest.json", "plugin.manifest.json"],
+  "pi": {"extensions": ["./dist/index.mjs"]},
+  "exports": {".": {"types": "./src/index.ts", "import": "./dist/index.mjs", "default": "./dist/index.mjs"}},
+  "scripts": {"build": "node scripts/build.mjs", "build:check": "node scripts/build.mjs --check", "typecheck": "tsc --noEmit", "test": "npm run build && node --test test/registration.test.mjs test/contracts.test.mjs", "smoke": "node scripts/smoke.mjs", "check": "npm run typecheck && npm run build:check && npm test && npm run smoke"},
+  "peerDependencies": {"@earendil-works/pi-coding-agent": ">=1.1.0 <2.0.0"},
+  "dependencies": {"@gyoungwe/plugin-api": "^1.0.0"},
+  "devDependencies": {"typescript": "^5.9.0", "esbuild": "^0.25.12"}
+}

package/plugin.manifest.json

@@ -0,0 +1,23 @@
+{
+	"schemaVersion": 1,
+	"id": "drone-pi-evidence",
+	"version": "0.1.0",
+	"pi": {
+		"apiVersion": 1,
+		"minHostVersion": "1.1.0",
+		"testedHosts": ["1.1.0", "latest"]
+	},
+	"drone": {
+		"pluginApi": 1,
+		"resultContract": "drone-result/v3"
+	},
+	"entrypoints": { "extension": "./dist/index.mjs" },
+	"capabilities": ["evidence", "provenance", "replay", "files"],
+	"hosts": ["native-pi", "drone-desktop"],
+	"permissions": {
+		"filesystem": [],
+		"network": [],
+		"subprocess": [],
+		"externalWrites": false
+	}
+}