prime-agent-dsh 0.2.0

package/extensions/index.ts

@@ -0,0 +1,161 @@
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { readdirSync, statSync } from "node:fs";
+import { basename, join } from "node:path";
+import { RecursiveContextLoader } from "../src/recursive-context-loader.js";
+import { RlmContextInheritance } from "../src/rlm-context-bootstrap.js";
+import { ShadowContextExtension } from "./shadow-context.js";
+
+/** Number of committed message entries in the current session (0 = fresh). */
+function committedMessages(ctx: ExtensionContext): number {
+  try {
+    return ctx.sessionManager.getBranch().filter((entry) => (entry as { type?: string }).type === "message").length;
+  } catch {
+    return 0;
+  }
+}
+
+/** Most recent sibling session file (same dir, older than this one), if fresh. */
+function recentSiblingSession(ctx: ExtensionContext): { id: string; ageMinutes: number } | undefined {
+  try {
+    const dir = ctx.sessionManager.getSessionDir();
+    const current = ctx.sessionManager.getSessionFile();
+    if (!dir || !current) return undefined;
+    const now = Date.now();
+    let best: { id: string; mtime: number } | undefined;
+    for (const name of readdirSync(dir)) {
+      if (!name.endsWith(".jsonl")) continue;
+      const full = join(dir, name);
+      if (full === current) continue;
+      let mtime: number;
+      try { mtime = statSync(full).mtimeMs; } catch { continue; }
+      if (!best || mtime > best.mtime) best = { id: basename(name, ".jsonl"), mtime };
+    }
+    if (!best || best.mtime >= now) return undefined;
+    const ageMinutes = Math.round((now - best.mtime) / 60000);
+    return ageMinutes <= 720 ? { id: best.id, ageMinutes } : undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+export const DSH_VERSION = "0.2.0";
+const CACHE_STATUS_KEY = "prime-agent-dsh-cache";
+const CACHE_WIDGET_KEY = "prime-agent-dsh-cache-widget";
+const INSTALLS_KEY = Symbol.for("prime-agent-dsh.installs.v1");
+
+export function defaultCacheDisplay(env: NodeJS.ProcessEnv = process.env): boolean {
+  const value = env.PRIME_DSH_CACHE_DISPLAY?.trim().toLowerCase();
+  return value !== "off" && value !== "false" && value !== "0";
+}
+
+type InstallRegistry = WeakSet<object>;
+type GlobalWithDshInstalls = typeof globalThis & { [INSTALLS_KEY]?: InstallRegistry };
+
+/** Process-global because separately loaded package copies do not share module state. */
+export function claimExtensionApi(pi: ExtensionAPI): boolean {
+  const global = globalThis as GlobalWithDshInstalls;
+  const installs = global[INSTALLS_KEY] ??= new WeakSet<object>();
+  if (installs.has(pi)) return false;
+  installs.add(pi);
+  return true;
+}
+
+function efficiencyText(value: number | null | undefined): string {
+  return value === null || value === undefined ? "—" : `${(value * 100).toFixed(1)}%`;
+}
+
+export function cacheFooterText(turnEfficiency: number | null | undefined, sessionEfficiency: number | null | undefined): string {
+  return `DSH cache · turn ${efficiencyText(turnEfficiency)} · session ${efficiencyText(sessionEfficiency)}`;
+}
+
+function canonicalSessionEfficiency(scope: ReturnType<RecursiveContextLoader["status"]>): number | null {
+  const metrics = scope?.lastSync?.manifest.metrics;
+  if (!metrics) return scope?.cache?.efficiency ?? null;
+  const total = metrics.inputTokens + metrics.cacheReadTokens;
+  return total > 0 ? metrics.cacheReadTokens / total : null;
+}
+
+function updateCacheStatus(ctx: ExtensionContext, loader: RecursiveContextLoader): void {
+  const scope = loader.status(ctx);
+  const text = cacheFooterText(scope?.latestCache?.efficiency, canonicalSessionEfficiency(scope));
+  ctx.ui.setStatus(CACHE_STATUS_KEY, text);
+  ctx.ui.setWidget(CACHE_WIDGET_KEY, [text], { placement: "aboveEditor" });
+}
+
+/**
+ * Prime owns the model loop, tools, transcript, and RLM tree. DSH contributes a
+ * rebuildable context projection, immutable Python-visible artifacts, cache
+ * observations. Prime alone owns compaction and DSH only indexes committed history.
+ */
+export default function deepSeekHarnessExtension(pi: ExtensionAPI): void {
+  if (!claimExtensionApi(pi)) return;
+  let showCacheDisplay = defaultCacheDisplay();
+  new ShadowContextExtension(pi).register(false);
+  const inheritance = new RlmContextInheritance();
+  inheritance.register(pi);
+  const contextLoader = new RecursiveContextLoader();
+  contextLoader.register(pi);
+  const refreshCacheDisplay = (ctx: ExtensionContext): void => {
+    if (showCacheDisplay) updateCacheStatus(ctx, contextLoader);
+    else {
+      ctx.ui.setStatus(CACHE_STATUS_KEY, undefined);
+      ctx.ui.setWidget(CACHE_WIDGET_KEY, undefined);
+    }
+  };
+
+  pi.on("session_start", async (_event, ctx) => {
+    await Promise.resolve();
+    refreshCacheDisplay(ctx);
+    if (!ctx.hasUI) return;
+    const modelLabel = ctx.model ? `${ctx.model.provider}/${ctx.model.id}` : "none";
+    const state = contextLoader.isEnabled(ctx) ? "on" : "off";
+    const inherited = inheritance.status(ctx);
+    const inheritanceLabel = inherited.state === "admitted" ? `admitted generation ${inherited.capsule.generation}` : inherited.state;
+    const inheritanceNotice = inheritanceLabel;
+    const messages = committedMessages(ctx);
+    if (messages > 0) {
+      ctx.ui.notify(`Session resumed (${messages} messages) · DSH context ${state} · inheritance ${inheritanceNotice} · Prime loop · model ${modelLabel}`, inherited.state === "degraded" || inherited.state === "incompatible" ? "warning" : "info");
+      return;
+    }
+    const sibling = recentSiblingSession(ctx);
+    const hint = sibling ? ` · a session from ${sibling.ageMinutes} min ago exists — resume it to keep context` : "";
+    ctx.ui.notify(`Fresh session · DSH context ${state} · inheritance ${inheritanceNotice} · Prime loop · model ${modelLabel}${hint}`, inherited.state === "degraded" || inherited.state === "incompatible" ? "warning" : "info");
+  });
+
+  pi.on("context", (_event, ctx) => { refreshCacheDisplay(ctx); });
+  pi.on("message_end", (event, ctx) => {
+    const latest = contextLoader.observeFinalizedAssistant(ctx, event.message);
+    if (latest) refreshCacheDisplay(ctx);
+  });
+  // Re-emit native status when a daemon UI can newly attach or replace its model.
+  pi.on("model_select", (_event, ctx) => { refreshCacheDisplay(ctx); });
+  pi.on("session_info_changed", (_event, ctx) => { refreshCacheDisplay(ctx); });
+  pi.on("session_shutdown", async (_event, ctx) => {
+    await Promise.resolve();
+    ctx?.ui?.setStatus?.(CACHE_STATUS_KEY, undefined);
+    ctx?.ui?.setWidget?.(CACHE_WIDGET_KEY, undefined);
+  });
+
+  pi.registerCommand("dsh", {
+    description: "Toggle DSH cache-rate text and report the resulting state",
+    handler: async (args, ctx) => {
+      await Promise.resolve();
+      const action = args.trim().toLowerCase();
+      if (action === "") showCacheDisplay = !showCacheDisplay;
+      else if (action === "on") showCacheDisplay = true;
+      else if (action === "off") showCacheDisplay = false;
+      else {
+        ctx.ui.notify("Usage: /dsh [on|off]", "warning");
+        return;
+      }
+      refreshCacheDisplay(ctx);
+      const scope = contextLoader.status(ctx);
+      const rates = cacheFooterText(scope?.latestCache?.efficiency, canonicalSessionEfficiency(scope)).replace(/^DSH cache · /u, "");
+      ctx.ui.notify(
+        `DSH ${DSH_VERSION} · cache text ${showCacheDisplay ? "ON" : "OFF"} · indexing ${contextLoader.isEnabled(ctx) ? "ACTIVE" : "PAUSED"} · ${rates}`,
+        scope?.lastError ? "warning" : "info",
+      );
+    },
+  });
+
+}

package/extensions/shadow-context.ts

@@ -0,0 +1,168 @@
+import { createHash } from "node:crypto";
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import type { Message } from "@deepseek-ai/dsh-llm";
+import { ShadowContextTelemetry, type ShadowLocation, type ShadowTraceEntry } from "../src/shadow-telemetry.js";
+import { ContextService } from "../src/dsh-context-service.js";
+import { ContextProtocolClient, type BranchKey } from "../src/context-protocol.js";
+import { primeToDshAsync, dshToPrimeAsync, type PrimeEnvelope, type PrimeMessage } from "../src/context-converter.js";
+import { stableJson } from "../src/prefix-metrics.js";
+import { LocalDshImageAttachments, type DshImageAttachmentGateway } from "../src/dsh-image-attachments.js";
+
+interface MirrorCounters {
+  syncs: number;
+  skips: number;
+  errors: number;
+  appends: number;
+  noops: number;
+  rebuilds: number;
+}
+interface SyncResult { revision: number; messageCount: number; mode: "append" | "noop" | "rebuild"; }
+interface ProjectResult { messages: Message[]; }
+export type ShadowMode = "off" | "on";
+export interface ShadowContextOptions { mode?: ShadowMode; maxMessages?: number; maxBytes?: number; }
+export function shadowOptions(env: NodeJS.ProcessEnv = process.env): Required<ShadowContextOptions> {
+  const rawMode = env.PRIME_DSH_SHADOW_MODE ?? "off";
+  if (rawMode !== "off" && rawMode !== "on") throw new Error("PRIME_DSH_SHADOW_MODE must be off or on");
+  const positive = (value: string | undefined, fallback: number): number => {
+    const parsed = value === undefined ? fallback : Number(value);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : fallback;
+  };
+  return { mode: rawMode, maxMessages: positive(env.PRIME_DSH_SHADOW_MAX_MESSAGES, 500), maxBytes: positive(env.PRIME_DSH_SHADOW_MAX_BYTES, 4 * 1024 * 1024) };
+}
+
+type JsonObject = Record<string, unknown>;
+const isObject = (value: unknown): value is JsonObject => typeof value === "object" && value !== null && !Array.isArray(value);
+function asPrimeInput(value: unknown): PrimeMessage | PrimeEnvelope {
+  if (!isObject(value)) throw new TypeError("Prime context message must be an object");
+  if (isObject(value.message) && typeof value.message.role === "string") return value as PrimeEnvelope;
+  if (typeof value.role === "string") return value as PrimeMessage;
+  throw new TypeError("Prime context message has no role");
+}
+function isSyncResult(value: unknown): value is SyncResult {
+  return isObject(value) && typeof value.revision === "number" && typeof value.messageCount === "number"
+    && (value.mode === "append" || value.mode === "noop" || value.mode === "rebuild");
+}
+function isProjectResult(value: unknown): value is ProjectResult {
+  return isObject(value) && Array.isArray(value.messages);
+}
+
+function location(ctx: ExtensionContext): ShadowLocation {
+  return { sessionId: ctx.sessionManager.getSessionId(), branchId: ctx.sessionManager.getLeafId() ?? "root" };
+}
+function metric(entry: ShadowTraceEntry | undefined): string {
+  if (!entry) return "none";
+  return `#${entry.request} ${entry.bytes}B sha256:${entry.digest.slice(0, 12)} lcp=${entry.commonPrefixBytes}B (${(entry.prefixRatio * 100).toFixed(1)}%) ${entry.reason}`;
+}
+
+/** Owns the fail-open DSH mirror lifecycle and typed protocol boundary. */
+export class ShadowMirrorController {
+  private readonly service: ContextService;
+  private readonly client: ContextProtocolClient;
+  private readonly revisions = new Map<string, number>();
+  readonly counters: MirrorCounters = { syncs: 0, skips: 0, errors: 0, appends: 0, noops: 0, rebuilds: 0 };
+
+  constructor(service = new ContextService(), private readonly attachments: DshImageAttachmentGateway = new LocalDshImageAttachments()) {
+    this.service = service;
+    this.client = new ContextProtocolClient(request => this.service.handle(request));
+    const initialized = this.client.call("initialize");
+    if (!initialized.ok) throw new Error(`Could not initialize context shadow: ${initialized.error.message}`);
+  }
+
+  async observe(messages: readonly unknown[], key: BranchKey): Promise<void> {
+    const encodedKey = JSON.stringify([key.sessionId, key.branchId]);
+    try {
+      const canonical = await Promise.all(messages.map((message, index) => primeToDshAsync(asPrimeInput(message), { admitImages: (images) => this.attachments.admitPrimeImages(images) }, this.messageId(message, index))));
+      const synced = this.client.call("session/sync-canonical", { key, messages: canonical, expectedRevision: this.revisions.get(encodedKey) ?? 0 });
+      if (!synced.ok || !isSyncResult(synced.result)) { this.counters.errors++; return; }
+      const projected = this.client.call("project", { key });
+      if (!projected.ok || !isProjectResult(projected.result)) { this.counters.errors++; return; }
+      const roundTrip = await Promise.all(projected.result.messages.map((message) => dshToPrimeAsync(message, { resolveImage: (attachment) => this.attachments.resolveDshImage(attachment) })));
+      if (stableJson(roundTrip) !== stableJson(messages)) { this.counters.skips++; return; }
+      this.revisions.set(encodedKey, synced.result.revision);
+      this.counters.syncs++;
+      if (synced.result.mode === "append") this.counters.appends++;
+      else if (synced.result.mode === "noop") this.counters.noops++;
+      else this.counters.rebuilds++;
+    } catch { this.counters.errors++; }
+  }
+
+  private messageId(message: unknown, index: number): string {
+    return `prime-${createHash("sha256").update(`${index}:`).update(stableJson(message)).digest("hex").slice(0, 32)}`;
+  }
+}
+
+/** Registers passive observers and owns their command-facing presentation. */
+export class ShadowContextExtension {
+  readonly telemetry: ShadowContextTelemetry;
+  readonly mirror: ShadowMirrorController | undefined;
+
+  private readonly options: Required<ShadowContextOptions>;
+  private boundedSkips = 0;
+  constructor(private readonly pi: ExtensionAPI, telemetry = new ShadowContextTelemetry(), mirror?: ShadowMirrorController, options: ShadowContextOptions = shadowOptions()) {
+    this.telemetry = telemetry;
+    this.options = { mode: options.mode ?? "off", maxMessages: options.maxMessages ?? 500, maxBytes: options.maxBytes ?? 4 * 1024 * 1024 };
+    this.mirror = this.options.mode === "on" ? (mirror ?? new ShadowMirrorController()) : undefined;
+  }
+
+  register(registerCommands = true): ShadowContextTelemetry {
+    if (this.options.mode === "on") {
+      this.pi.on("context", (event, ctx) => {
+        const here = location(ctx);
+        if (event.messages.length > this.options.maxMessages || Buffer.byteLength(stableJson(event.messages)) > this.options.maxBytes) { this.boundedSkips++; return; }
+        this.telemetry.observe("context", event.messages, here);
+        if (this.mirror) void this.mirror.observe(event.messages, here);
+      });
+      this.pi.on("before_provider_request", (event, ctx) => {
+        this.telemetry.observe("before_provider_request", event.payload, location(ctx));
+      });
+    }
+    if (registerCommands) {
+      this.registerStatusCommand();
+      this.registerTraceCommand();
+    }
+    return this.telemetry;
+  }
+
+  notifyStatus(ctx: ExtensionContext): void {
+    const here = location(ctx);
+    if (this.options.mode === "off") { ctx.ui.notify("DSH context shadow is off (normal Prime path). Set PRIME_DSH_SHADOW_MODE=on and reload to enable diagnostics.", "info"); return; }
+    const status = this.telemetry.status(here.sessionId, here.branchId) ?? this.telemetry.status(here.sessionId);
+    if (!status) { ctx.ui.notify(`DSH context shadow: no observations for session ${here.sessionId}`, "info"); return; }
+    const c = this.mirror?.counters ?? { syncs: 0, skips: 0, errors: 0, appends: 0, noops: 0, rebuilds: 0 };
+    ctx.ui.notify(`DSH context shadow session=${status.sessionId} branch=${status.branchId} observations=${status.observations} errors=${status.errors}
+context ${metric(status.context)}
+provider ${metric(status.provider)}
+DSH mode=${this.options.mode} bounded-skips=${this.boundedSkips}
+DSH mirror syncs=${c.syncs} append=${c.appends} noop=${c.noops} rebuild=${c.rebuilds} skips=${c.skips} errors=${c.errors}`, status.errors || c.errors ? "warning" : "info");
+  }
+
+  private registerStatusCommand(): void {
+    this.pi.registerCommand("dsh-context-status", {
+      description: "Show passive Prime context/provider prefix telemetry",
+      handler: async (_args, ctx) => { await Promise.resolve(); this.notifyStatus(ctx); },
+    });
+  }
+
+  notifyTrace(args: string, ctx: ExtensionContext): void {
+    const here = location(ctx);
+    const arg = args.trim().toLowerCase();
+    if (arg === "clear") { this.telemetry.clear(here.sessionId); ctx.ui.notify("DSH context shadow trace cleared for this session", "info"); return; }
+    const requested = arg ? Number.parseInt(arg, 10) : 10;
+    const count = Number.isFinite(requested) ? Math.min(Math.max(requested, 1), 50) : 10;
+    const entries = this.telemetry.traces(here.sessionId, count);
+    const text = entries.length ? entries.map((entry) => `${entry.observedAt} branch=${entry.branchId} ${entry.stage} ${metric(entry)}`).join("\n") : "No context shadow trace observations.";
+    ctx.ui.notify(text, "info");
+  }
+
+  private registerTraceCommand(): void {
+    this.pi.registerCommand("dsh-context-trace", {
+      description: "Show or clear passive context fingerprint trace (/dsh-context-trace [count|clear])",
+      handler: async (args, ctx) => { await Promise.resolve(); this.notifyTrace(args, ctx); },
+    });
+  }
+}
+
+/** Compatibility entry point used by the package extension. */
+export function registerShadowContextTelemetry(pi: ExtensionAPI): ShadowContextTelemetry {
+  return new ShadowContextExtension(pi).register();
+}

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "prime-agent-dsh",
+  "version": "0.2.0",
+  "description": "DeepSeek Harness context sidecar and Python context objects for Prime Agent.",
+  "keywords": [
+    "prime-agent",
+    "prime-agent-package",
+    "pi-package",
+    "context-management",
+    "context-window",
+    "deepseek-harness"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moreWax/prime-agent-dsh.git"
+  },
+  "homepage": "https://github.com/moreWax/prime-agent-dsh#readme",
+  "bugs": {
+    "url": "https://github.com/moreWax/prime-agent-dsh/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "type": "module",
+  "license": "MIT",
+  "files": [
+    "extensions/index.ts",
+    "extensions/shadow-context.ts",
+    "src/context-converter.ts",
+    "src/context-objects.ts",
+    "src/context-protocol.ts",
+    "src/durable-context-store.ts",
+    "src/dsh-context-service.ts",
+    "src/dsh-image-attachments.ts",
+    "src/prefix-metrics.ts",
+    "src/recursive-context-loader.ts",
+    "src/rlm-context-bootstrap.ts",
+    "src/rlm-context-inheritance.ts",
+    "src/shadow-telemetry.ts",
+    "src/context-spill.ts",
+    "src/durable-context-query.ts",
+    "src/durable-file-attachments.ts",
+    "src/provider-cache-series.ts",
+    "skills/dsh-context/SKILL.md",
+    "skills/dsh-context/pyproject.toml",
+    "skills/dsh-context/src/dsh_context/__init__.py",
+    "docs/shadow-telemetry-validation.md",
+    "scripts/patch-pi-ai-partial-json.mjs",
+    "docs/context-spill.md",
+    "docs/durable-context-query.md",
+    "docs/single-window-cache-architecture.md",
+    "scripts/package-smoke.mjs",
+    "README.md",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md",
+    "CHANGELOG.md",
+    "SECURITY.md",
+    "docs/getting-started.md",
+    "docs/security.md"
+  ],
+  "pi": {
+    "extensions": [
+      "./extensions/index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test tests/*.test.ts",
+    "test:python": "PYTHONPATH=skills/dsh-context/src python3 -m unittest discover -s tests/python -p 'test_*.py'",
+    "check": "npm run typecheck && npm run lint && npm test && npm run test:python",
+    "lint": "eslint \"src/**/*.ts\" \"extensions/**/*.ts\" \"tests/**/*.ts\"",
+    "package:smoke": "node scripts/package-smoke.mjs",
+    "release:check": "npm run check && npm run package:smoke",
+    "prepublishOnly": "npm run release:check",
+    "postinstall": "node scripts/patch-pi-ai-partial-json.mjs"
+  },
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.0.2",
+    "@deepseek-ai/dsh-attachment": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-attachment-local": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-llm": "0.1.6-alpha.2",
+    "@deepseek-ai/dsh-session": "0.1.6-alpha.2",
+    "partial-json": "0.1.7"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": ">=0.86.1",
+    "@earendil-works/pi-coding-agent": ">=0.86.1",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/js-yaml": "^4.0.9",
+    "@types/node": "^22.0.0",
+    "eslint": "^10.9.1",
+    "tsx": "^4.20.0",
+    "typescript": "^5.9.0",
+    "typescript-eslint": "^8.69.0",
+    "@earendil-works/pi-ai": "0.86.1",
+    "@earendil-works/pi-coding-agent": "0.86.1",
+    "typebox": "1.3.34"
+  },
+  "engines": {
+    "node": "^22.19.0 || >=24.0.0"
+  }
+}

package/scripts/package-smoke.mjs

@@ -0,0 +1,148 @@
+import assert from "node:assert/strict";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { basename, dirname, join, resolve } from "node:path";
+import { spawnSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+const originalHome = process.env.HOME ?? process.env.USERPROFILE;
+const repositoryUrl = "https://github.com/moreWax/prime-agent-dsh";
+const expectedKeywords = [
+  "prime-agent", "prime-agent-package", "pi-package", "context-management", "context-window", "deepseek-harness",
+];
+const communityFiles = [
+  "CHANGELOG.md",
+  "CODE_OF_CONDUCT.md",
+  "CONTRIBUTING.md",
+  "ROADMAP.md",
+  "SECURITY.md",
+  "SUPPORT.md",
+  "docs/getting-started.md",
+  "docs/security.md",
+  ".github/dependabot.yml",
+  ".github/ISSUE_TEMPLATE/bug_report.yml",
+  ".github/ISSUE_TEMPLATE/config.yml",
+  ".github/ISSUE_TEMPLATE/feature_request.yml",
+  ".github/PULL_REQUEST_TEMPLATE.md",
+  ".github/workflows/ci.yml",
+  ".github/workflows/publish.yml",
+];
+const expected = [
+  "CHANGELOG.md", "LICENSE", "README.md", "SECURITY.md", "THIRD_PARTY_NOTICES.md", "package.json",
+  "docs/context-spill.md", "docs/durable-context-query.md", "docs/getting-started.md", "docs/security.md", "docs/shadow-telemetry-validation.md", "docs/single-window-cache-architecture.md",
+  "extensions/index.ts", "extensions/shadow-context.ts", "scripts/package-smoke.mjs", "scripts/patch-pi-ai-partial-json.mjs",
+  "skills/dsh-context/SKILL.md", "skills/dsh-context/pyproject.toml", "skills/dsh-context/src/dsh_context/__init__.py",
+  "src/context-converter.ts", "src/context-objects.ts", "src/context-protocol.ts", "src/context-spill.ts",
+  "src/dsh-context-service.ts", "src/durable-context-query.ts", "src/durable-context-store.ts", "src/durable-file-attachments.ts", "src/dsh-image-attachments.ts", "src/prefix-metrics.ts", "src/provider-cache-series.ts", "src/recursive-context-loader.ts", "src/rlm-context-bootstrap.ts", "src/rlm-context-inheritance.ts", "src/shadow-telemetry.ts",
+].sort();
+
+function run(command, args, options = {}) {
+  const result = spawnSync(command, args, { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], ...options });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`${command} ${args.join(" ")} failed (${result.status})\n${result.stdout}${result.stderr}`);
+  return result.stdout;
+}
+
+for (const path of communityFiles) {
+  const contents = await readFile(join(root, path), "utf8");
+  assert(contents.trim().length > 0, `${path} must not be empty`);
+}
+const ciWorkflow = await readFile(join(root, ".github/workflows/ci.yml"), "utf8");
+assert.match(ciWorkflow, /node: \[22, 24\]/, "CI must test all supported Node.js majors");
+assert.match(ciWorkflow, /npm ci[\s\S]*npm run release:check/, "CI must validate the clean install");
+const publishWorkflow = await readFile(join(root, ".github/workflows/publish.yml"), "utf8");
+assert.match(publishWorkflow, /id-token: write/, "npm trusted publishing needs OIDC permission");
+assert.match(publishWorkflow, /npm publish --access public --provenance/, "release publishing must include provenance");
+assert(!/npm_[A-Za-z0-9]{20,}/.test(publishWorkflow), "publish workflow appears to contain an npm token");
+
+const temp = await mkdtemp(join(tmpdir(), "prime-agent-dsh-pack-"));
+try {
+  const home = join(temp, "home");
+  await (await import("node:fs/promises")).mkdir(home);
+  const isolatedEnv = { ...process.env, HOME: home, USERPROFILE: home, XDG_CONFIG_HOME: join(home, ".config") };
+  if (originalHome) isolatedEnv.npm_config_cache = join(originalHome, ".npm");
+  Object.assign(process.env, { HOME: home, USERPROFILE: home, XDG_CONFIG_HOME: join(home, ".config") });
+  const packOutput = run(npm, ["pack", "--json", "--ignore-scripts", "--pack-destination", temp], { cwd: root, env: isolatedEnv });
+  const pack = JSON.parse(packOutput)[0];
+  assert(pack?.filename, "npm pack did not report a tarball");
+  const actual = pack.files.map(({ path }) => path).sort();
+  assert.deepEqual(actual, expected, "packed artifact does not match the release allowlist");
+  assert(!actual.some((path) => /(^|\/)(test|tests|fixtures)(\/|$)|(?:^|\.)test\.[^/]+$/i.test(path)), "test material leaked into the tarball");
+  assert(!actual.some((path) => /(^|\/)(?:\.env(?:\.|$)|\.npmrc$|\.pypirc$|auth\.json$|credentials?(?:\.|\/|$)|id_rsa$)|\.(?:pem|key|p12)$/i.test(path)), "a secret-bearing filename leaked into the tarball");
+  assert(!actual.some((path) => path.startsWith(".github/")), "repository community files leaked into the runtime package");
+  assert(!actual.some((path) => /(?:dsh-provider|model-wrapper|agent-pool|branch-checkpoint|acp-client|transparent-routing)/i.test(path)), "legacy model/agent-loop source leaked into the tarball");
+
+  const project = join(temp, "consumer");
+  const { mkdir } = await import("node:fs/promises");
+  await mkdir(project);
+  run(npm, ["init", "--yes"], { cwd: project, env: isolatedEnv });
+  const tarball = join(temp, pack.filename);
+  run(npm, ["install", "--omit=dev", tarball,
+    "@earendil-works/pi-coding-agent@0.86.1", "@earendil-works/pi-ai@0.86.1", "typebox@1.3.34"], { cwd: project, env: isolatedEnv });
+
+  const installed = join(project, "node_modules", "prime-agent-dsh");
+  const manifest = JSON.parse(await readFile(join(installed, "package.json"), "utf8"));
+  assert.equal(manifest.version, "0.2.0", "packed plugin version is stale");
+  assert.deepEqual(manifest.repository, { type: "git", url: `git+${repositoryUrl}.git` });
+  assert.equal(manifest.homepage, `${repositoryUrl}#readme`);
+  assert.deepEqual(manifest.bugs, { url: `${repositoryUrl}/issues` });
+  assert.deepEqual(manifest.publishConfig, { access: "public", provenance: true });
+  assert.deepEqual(manifest.keywords, expectedKeywords);
+  assert.equal(manifest.funding, undefined, "do not advertise a funding destination that the project does not provide");
+  assert.equal(manifest.peerDependencies["@earendil-works/pi-coding-agent"], ">=0.86.1");
+  assert.deepEqual(manifest.pi, { extensions: ["./extensions/index.ts"], skills: ["./skills"] });
+  const packedReadme = await readFile(join(installed, "README.md"), "utf8");
+  assert.match(packedReadme, /Getting started/);
+  const packedGettingStarted = await readFile(join(installed, "docs", "getting-started.md"), "utf8");
+  assert.match(packedGettingStarted, /Agents[\s\S]*Ctrl\+X[^\n]*twice/);
+  assert.match(packedGettingStarted, /Prime deletes the matching session artifact directory/);
+  assert.deepEqual(
+    Object.keys(manifest.dependencies).filter((name) => name.startsWith("@deepseek-ai/")).sort(),
+    ["@deepseek-ai/cordis", "@deepseek-ai/dsh-attachment", "@deepseek-ai/dsh-attachment-local", "@deepseek-ai/dsh-llm", "@deepseek-ai/dsh-session"],
+    "production package must depend only on sidecar DSH components",
+  );
+  const piAiCandidates = [
+    join(installed, "node_modules", "@earendil-works", "pi-ai", "dist", "utils", "json-parse.js"),
+    join(project, "node_modules", "@earendil-works", "pi-ai", "dist", "utils", "json-parse.js"),
+  ];
+  let patchedPiAi;
+  for (const candidate of piAiCandidates) {
+    try { patchedPiAi = await readFile(candidate, "utf8"); break; } catch { /* try npm's other legal placement */ }
+  }
+  assert.match(patchedPiAi ?? "", /\.\.\/\.\.\/\.\.\/\.\.\/partial-json\/dist\/index\.js/, "Bun partial-json compatibility patch was not applied");
+
+  const host = await import(pathToFileURL(join(project, "node_modules", "@earendil-works", "pi-coding-agent", "dist", "index.js")));
+  const settingsManager = host.SettingsManager.inMemory({ packages: [installed] }, { projectTrusted: true });
+  const loader = new host.DefaultResourceLoader({ cwd: project, agentDir: join(temp, "home", ".prime", "agent"), settingsManager, noContextFiles: true });
+  await loader.reload();
+  let extensions = loader.getExtensions();
+  let skills = loader.getSkills();
+  assert.equal(extensions.errors.length, 0, JSON.stringify(extensions.errors));
+  assert.equal(extensions.extensions.length, 1, "Prime did not discover exactly one package extension");
+  assert.equal(extensions.extensions[0].tools.size, 0, "context-sidecar extension must not replace Prime tools");
+  assert.equal((extensions.extensions[0].handlers.get("before_agent_start") ?? []).length, 1, "task-aware inheritance admission handler is missing");
+  assert((extensions.extensions[0].handlers.get("context") ?? []).length >= 2, "inheritance ordering/context projection handlers are missing");
+  for (const event of ["message_end", "model_select", "session_info_changed", "session_shutdown"]) {
+    assert((extensions.extensions[0].handlers.get(event) ?? []).length > 0, `${event} native lifecycle handler is missing`);
+  }
+  assert.equal(extensions.extensions[0].messageRenderers.size, 0, "status must not use a custom message/footer renderer");
+  assert(!skills.skills.some(({ name }) => name === "deepseek-harness"), "legacy delegation skill must not ship without its removed tool");
+  assert(skills.skills.some(({ name }) => name === "dsh-context"), "Prime did not discover the dsh-context skill");
+  assert.equal(skills.diagnostics.length, 0, JSON.stringify(skills.diagnostics));
+  const shutdownHandlers = extensions.extensions[0].handlers.get("session_shutdown") ?? [];
+  assert(shutdownHandlers.length > 0, "extension did not register session_shutdown cleanup");
+  for (const handler of shutdownHandlers) await handler({}, {});
+
+  await loader.reload();
+  extensions = loader.getExtensions();
+  skills = loader.getSkills();
+  assert.equal(extensions.errors.length, 0, "extension reload produced an error");
+  assert.equal(extensions.extensions.length, 1, "extension was not retained across reload");
+  assert(!skills.skills.some(({ name }) => name === "deepseek-harness"), "legacy delegation skill returned after reload");
+  assert(skills.skills.some(({ name }) => name === "dsh-context"), "context skill was not retained across reload");
+  console.log(`package smoke passed: ${actual.length} files; production install; extension + context skill discovery; reload`);
+} finally {
+  await rm(temp, { recursive: true, force: true });
+}

package/scripts/patch-pi-ai-partial-json.mjs

@@ -0,0 +1,14 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const entry = fileURLToPath(import.meta.resolve("@earendil-works/pi-ai"));
+const target = join(dirname(entry), "utils", "json-parse.js");
+const bare = 'from "partial-json"';
+const relative = 'from "../../../../partial-json/dist/index.js"';
+const source = await readFile(target, "utf8");
+if (source.includes(relative)) process.exit(0);
+if (!source.includes(bare)) {
+  throw new Error(`Cannot apply Prime Bun compatibility patch: unexpected ${target}`);
+}
+await writeFile(target, source.replace(bare, relative));