@danypops/papyrus 0.8.0 → 0.9.0

package/README.md

@@ -174,7 +174,9 @@ checklist: {
 
 Proof types are `file`, `symbol`, `code`, `test`, `command`, `artifact`, and `url`. Existing array checklists remain readable as legacy items with `proof: missing`; Papyrus does not invent evidence.
 
-Papyrus also injects an Alef-style reconciliation block on every agent turn while work remains: `Current`, `Desired`, `Verify`, and `Next`. The agent is explicitly instructed to ask **“Did we accomplish this task?”** and run review before marking it done. The injection disappears when every task is done or canceled.
+Papyrus also injects an Alef-style reconciliation block at `before_agent_start` while work remains: `Current`, `Desired`, `Verify`, and `Next`. The agent is explicitly instructed to ask **“Did we accomplish this task?”** and run review before marking it done. The injection disappears when every task is done or canceled.
+
+After assembling each system-prompt addition, Papyrus emits a versioned `papyrus.context-injection.v1` observation on Pi's shared extension event bus. It contains only exact byte/character sizes, Rule count, a labeled token estimate, prompt share, sequence, and a SHA-256 payload fingerprint; Rule/Task text, prompts, project paths, and credentials are never included. Jittor can persist and assess these observations without Papyrus maintaining a second telemetry store.
 
 Task edits mutate the existing Papyrus-owned Task identity and append an `updated` event; title, body, and labels can be revised without canceling the Task or creating a replacement. Lifecycle, relationships, gates, checklist metadata, scope, and focus remain intact.
 

package/extension/src/context-injection-telemetry.ts

@@ -0,0 +1,80 @@
+import { createHash } from "node:crypto";
+import {
+	CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN,
+	PAPYRUS_CONTEXT_INJECTION_SCHEMA,
+} from "../../src/constants.ts";
+import type { Artifact } from "../../src/domain/artifact.ts";
+import { ruleInjectionPreview } from "./rules.ts";
+
+export interface ContextPayloadSize {
+	characters: number;
+	bytes: number;
+}
+
+export interface PapyrusContextInjectionObservation {
+	schema: typeof PAPYRUS_CONTEXT_INJECTION_SCHEMA;
+	observedAt: number;
+	sequence: number;
+	producerId: string;
+	before: ContextPayloadSize;
+	rules: ContextPayloadSize & { count: number };
+	tasks: ContextPayloadSize;
+	injected: ContextPayloadSize;
+	after: ContextPayloadSize;
+	estimatedTokens: number;
+	share: number;
+	fingerprint: string;
+	unchanged: boolean;
+}
+
+export interface BuildContextInjectionInput {
+	basePrompt: string;
+	rules: Array<Pick<Artifact, "title" | "body" | "extra">>;
+	taskSummary: string | null;
+	observedAt: number;
+	sequence: number;
+	producerId: string;
+	previousFingerprint?: string;
+}
+
+const encoder = new TextEncoder();
+
+function size(value: string): ContextPayloadSize {
+	return { characters: value.length, bytes: encoder.encode(value).byteLength };
+}
+
+export function buildContextInjection(input: BuildContextInjectionInput): {
+	prompt: string;
+	ruleBlock: string;
+	taskBlock: string;
+	observation: PapyrusContextInjectionObservation;
+} {
+	const ruleContent = input.rules.map(ruleInjectionPreview).join("\n");
+	const ruleBlock = ruleContent ? `\n\n## Active rules (Papyrus)\n\n${ruleContent}\n` : "";
+	const taskBlock = input.taskSummary ? `\n\n## Open tasks (Papyrus)\n\n${input.taskSummary}\n` : "";
+	const injected = `${ruleBlock}${taskBlock}`;
+	const prompt = `${input.basePrompt}${injected}`;
+	const fingerprint = createHash("sha256").update(injected).digest("hex");
+	const injectedSize = size(injected);
+	const afterSize = size(prompt);
+	return {
+		prompt,
+		ruleBlock,
+		taskBlock,
+		observation: {
+			schema: PAPYRUS_CONTEXT_INJECTION_SCHEMA,
+			observedAt: input.observedAt,
+			sequence: input.sequence,
+			producerId: input.producerId,
+			before: size(input.basePrompt),
+			rules: { ...size(ruleBlock), count: input.rules.length },
+			tasks: size(taskBlock),
+			injected: injectedSize,
+			after: afterSize,
+			estimatedTokens: Math.ceil(injectedSize.characters / CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN),
+			share: afterSize.characters === 0 ? 0 : injectedSize.characters / afterSize.characters,
+			fingerprint,
+			unchanged: input.previousFingerprint === fingerprint,
+		},
+	};
+}

package/extension/src/index.ts

@@ -7,12 +7,14 @@
  * Injection: active rules + open tasks appended to system prompt every turn.
  *             "Are we there yet?" — the agent sees its open work items.
  */
+import { randomUUID } from "node:crypto";
 import type { ExtensionAPI, ExtensionContext, ExtensionUIContext, Theme } from "@earendil-works/pi-coding-agent";
 import { Type } from "typebox";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import {
 	TASK_DRIVER_MAX_TURNS,
 	TASK_DRIVER_MAX_UNCHANGED_TURNS,
+	PAPYRUS_CONTEXT_INJECTION_CHANNEL,
 } from "../../src/constants.ts";
 import type { Artifact } from "../../src/domain/artifact.ts";
 import type { GateResult } from "../../src/domain/gate.ts";
@@ -23,6 +25,7 @@ import type { TaskGraph, TaskStatus } from "../../src/task-service.ts";
 import { ActiveTaskContinuation, automaticPauseReason, shouldResumeFocusOnHumanInput, type ActiveTaskMarker } from "./active-task-continuation.ts";
 import { buildTaskWidgetProjection, type TaskWidgetProjection } from "./task-widget.ts";
 import { TASK_STATUS_PRESENTATION, taskTreeConnector } from "./task-presentation.ts";
+import { buildContextInjection } from "./context-injection-telemetry.ts";
 
 function text(t: string, details: Record<string, unknown> = {}) {
 	return { content: [{ type: "text" as const, text: t }], details };
@@ -130,6 +133,9 @@ class TaskOverlay {
 
 export default async function (pi: ExtensionAPI) {
 	registerDomainTools(pi);
+	let contextInjectionSequence = 0;
+	const contextInjectionProducerId = randomUUID();
+	let previousContextInjectionFingerprint: string | undefined;
 	const taskContinuation = new ActiveTaskContinuation({
 		maxTurns: TASK_DRIVER_MAX_TURNS,
 		maxUnchangedTurns: TASK_DRIVER_MAX_UNCHANGED_TURNS,
@@ -391,17 +397,18 @@ export default async function (pi: ExtensionAPI) {
 				callService<Record<string, unknown>, Array<Pick<Artifact, "title" | "body" | "extra">>>("rules.injectable", { project_root: ctx.cwd }),
 				callService<Record<string, unknown>, string | null>("tasks.context", { project_root: ctx.cwd }),
 			]);
-			let prompt = event.systemPrompt ?? "";
-			if (rules.length > 0) {
-				const block = rules.map(rulesModule.ruleInjectionPreview).join("\n");
-				prompt += `\n\n## Active rules (Papyrus)\n\n${block}\n`;
-			}
-			if (summary) {
-				prompt += `\n\n## Open tasks (Papyrus)\n\n${summary}\n`;
-			}
-			if (prompt !== (event.systemPrompt ?? "")) {
-				return { systemPrompt: prompt };
-			}
+			const injection = buildContextInjection({
+				basePrompt: event.systemPrompt ?? "",
+				rules,
+				taskSummary: summary,
+				observedAt: Date.now(),
+				sequence: ++contextInjectionSequence,
+				producerId: contextInjectionProducerId,
+				previousFingerprint: previousContextInjectionFingerprint,
+			});
+			previousContextInjectionFingerprint = injection.observation.fingerprint;
+			pi.events.emit(PAPYRUS_CONTEXT_INJECTION_CHANNEL, injection.observation);
+			if (injection.prompt !== (event.systemPrompt ?? "")) return { systemPrompt: injection.prompt };
 		} catch {
 			// DB not ready
 		}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danypops/papyrus",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Daemon-backed graph artifacts, evidence-bearing tasks, rules, skills, and native TUI workflows for Pi",
   "type": "module",
   "keywords": ["pi-package"],

package/src/constants.ts

@@ -17,6 +17,10 @@ export const GATE_OUTPUT_LIMIT = 200;
 export const GATE_MAX_BUFFER_BYTES = 1_048_576;
 export const GATE_FILE_MAX_BYTES = 1_048_576;
 
+export const PAPYRUS_CONTEXT_INJECTION_CHANNEL = "papyrus.context-injection.v1";
+export const PAPYRUS_CONTEXT_INJECTION_SCHEMA = "papyrus.context-injection/v1";
+export const CONTEXT_ESTIMATE_CHARACTERS_PER_TOKEN = 4;
+
 /** Compact task-context limits keep recurring prompt injection bounded. */
 export const TASK_CONTEXT_CURRENT_LIMIT = 3;
 export const TASK_CONTEXT_REJECTED_LIMIT = 3;