pi-harness-runtime 1.1.410 → 1.1.412

package/harness/startup-report.ts

@@ -13,7 +13,7 @@
 
 import type { KeyFileAuditResult } from "./key-file-audit.ts";
 
-export type StartupStatus = "wait" | "ok" | "warn" | "err";
+export type StartupStatus = "wait" | "ok" | "info" | "warn" | "err";
 
 export interface StartupReport {
 	/** The label of the startup line ("Jev", "Relay", "LINE"). */
@@ -141,12 +141,28 @@ export function relayEndpointReport(options: {
 	};
 }
 
+/**
+ * The two steps that create a usable LINE channel.
+ *
+ * They are shown whenever the credentials are missing: a warning that names
+ * only the key files leaves the user without a way to get the values.
+ */
+export const LINE_SETUP_STEPS: readonly string[] = [
+	"Create a LINE Messaging API channel in LINE Developers Console.",
+	"Issue a Long-term channel access token and get Your user ID from Basic settings.",
+];
+
 /**
  * The LINE line.
  *
- * Returns null when LINE must not be reported at all: a user who never
- * touched LINE must not see a warning on every start. The line appears as
- * soon as one of the LINE client key files exists.
+ * The line is ALWAYS reported: Telegram and LINE are the two notification
+ * channels, and a fresh install must show both of them next to each other -
+ * a user who has never heard of LINE cannot miss the channel they do not
+ * have yet.
+ *
+ * "Disabled" is never inferred from the absence of key files. Only an
+ * explicit opt-out (the user turned the channel off) produces the
+ * informational disabled state.
  *
  * The audit is passed in (and not read here) so that the rule "never report
  * LINE as configured when the audit failed" can be tested.
@@ -154,8 +170,13 @@ export function relayEndpointReport(options: {
 export function lineConfigurationReport(options: {
 	/** The audit result, or null when the audit could not run. */
 	audit: KeyFileAuditResult | null;
-	/** Does a LINE client key file exist (line-access-token.txt / line-user-id.txt)? */
-	clientKeyFilePresent: boolean;
+	/**
+	 * Did the user explicitly turn the LINE channel off?
+	 *
+	 * A missing key file is NOT a disabled channel - it is a channel that was
+	 * never configured.
+	 */
+	disabled?: boolean;
 	/**
 	 * The fix commands for Telegram.
 	 *
@@ -196,8 +217,22 @@ export function lineConfigurationReport(options: {
 	 */
 	channelDiagnostic?: string | null;
 }): StartupReport | null {
-	if (!options.clientKeyFilePresent) return null;
 	const channelState = options.channelState ?? "not-started";
+
+	// An explicit opt-out is an information, not a warning: the user asked
+	// for it and the channel works as told.
+	if (options.disabled) {
+		return {
+			label: "LINE",
+			text: "disabled",
+			status: "info",
+			details: [
+				"The LINE channel is turned off in the notification settings.",
+				"Turn it on again with: /notify-settings line on",
+			],
+		};
+	}
+
 	if (!options.audit) {
 		// The audit failed: LINE must not be reported as configured.
 		const details = options.fixes.length > 0 ? options.fixes : [];
@@ -214,64 +249,71 @@ export function lineConfigurationReport(options: {
 		};
 	}
 	const missing = options.audit.byFeature.get("LINE") ?? [];
-	if (missing.length === 0) {
-		if (channelState === "started") {
-			// The runtime reported the green line itself ("configured and
-			// enabled") - a second LINE line would only overwrite it.
-			return null;
-		}
-		if (channelState === "failed") {
-			// The credentials are there but the channel did not start - the
-			// channel access token is what the startup check validates, so
-			// the user id must not be named as the cause.
-			const details = [
-				...(options.accessTokenFixes && options.accessTokenFixes.length > 0
-					? options.accessTokenFixes
-					: options.fixes),
-			];
-			if (options.channelDiagnostic) {
-				details.push(options.channelDiagnostic);
-			}
-			details.push(
-				"The startup check validates the channel access token - the user id is only the recipient of the messages.",
-			);
-			details.push(
-				"Fix the file, then reload Pi so the channel is checked again.",
-			);
-			return {
-				label: "LINE",
-				text: "configured but the LINE channel did not start",
-				status: "warn",
-				details,
-			};
-		}
-		// The credentials are there but the channel was never started in this
-		// run - say so instead of showing a green line. The cause differs:
-		// without Telegram the channel cannot start at all, with Telegram the
-		// credentials were simply created after the harness was loaded.
-		const cause = options.telegramConfigured
-			? "The LINE channel starts together with the Telegram channel - the key files were created after Pi was loaded."
-			: "The LINE channel starts together with the Telegram channel - it cannot start before Telegram works.";
+	if (missing.length > 0) {
+		// The credentials are missing (no key file at all, or a file the
+		// reader rejects). The warning names the two files AND the two steps
+		// that produce their values - otherwise the user is stuck.
 		return {
 			label: "LINE",
-			// The text names the action - a reload only helps when Telegram
-			// works; otherwise the user has to configure Telegram first.
-			text: options.telegramConfigured
-				? "configured; reload Pi to enable the channel"
-				: "configured; Telegram must be configured first",
+			text: "credentials missing; notifications unavailable",
 			status: "warn",
 			details: [
-				cause,
-				// Without Telegram the user needs the Telegram commands - the
-				// line must not be the only warning without an action.
-				...(options.telegramConfigured ? [] : (options.telegramFixes ?? [])),
+				...LINE_SETUP_STEPS,
+				...options.fixes,
+				"Then reload Pi so the channel is checked again.",
 			],
 		};
 	}
+	if (channelState === "started") {
+		// The runtime reported the green line itself ("configured and
+		// enabled") - a second LINE line would only overwrite it.
+		return null;
+	}
+	if (channelState === "failed") {
+		// The credentials are there but the channel did not start - the
+		// channel access token is what the startup check validates, so
+		// the user id must not be named as the cause.
+		const details = [
+			...(options.accessTokenFixes && options.accessTokenFixes.length > 0
+				? options.accessTokenFixes
+				: options.fixes),
+		];
+		if (options.channelDiagnostic) {
+			details.push(options.channelDiagnostic);
+		}
+		details.push(
+			"The startup check validates the channel access token - the user id is only the recipient of the messages.",
+		);
+		details.push(
+			"Fix the file, then reload Pi so the channel is checked again.",
+		);
+		return {
+			label: "LINE",
+			text: "configured but the LINE channel did not start",
+			status: "warn",
+			details,
+		};
+	}
+	// The credentials are there but the channel was never started in this
+	// run - say so instead of showing a green line. The cause differs:
+	// without Telegram the channel cannot start at all, with Telegram the
+	// credentials were simply created after the harness was loaded.
+	const cause = options.telegramConfigured
+		? "The LINE channel starts together with the Telegram channel - the key files were created after Pi was loaded."
+		: "The LINE channel starts together with the Telegram channel - it cannot start before Telegram works.";
 	return {
 		label: "LINE",
-		text: "not configured",
+		// The text names the action - a reload only helps when Telegram
+		// works; otherwise the user has to configure Telegram first.
+		text: options.telegramConfigured
+			? "configured; reload Pi to enable the channel"
+			: "configured; Telegram must be configured first",
 		status: "warn",
-		details: [...options.fixes, "Configure LINE in ~/.pi-harness-runtime/keys/, then reload Pi."],
+		details: [
+			cause,
+			// Without Telegram the user needs the Telegram commands - the
+			// line must not be the only warning without an action.
+			...(options.telegramConfigured ? [] : (options.telegramFixes ?? [])),
+		],
 	};
 }

package/harness-startup-status.ts

@@ -1,4 +1,4 @@
-export type HarnessStatus = "wait" | "ok" | "warn" | "err";
+export type HarnessStatus = "wait" | "ok" | "info" | "warn" | "err";
 
 export interface HarnessMessage {
 	id: string;
@@ -20,8 +20,37 @@ export class HarnessStartupStatus {
 		else this.messages[existing] = next;
 		this.onChange?.();
 	}
+
+	/**
+	 * Put a message directly after another one.
+	 *
+	 * Two rows that belong together stay together: the notification channels
+	 * (Telegram and LINE) must not be separated by a row that another
+	 * feature added in between. A message that does not exist yet is
+	 * inserted; an existing one is moved.
+	 */
+	updateAfter(
+		anchorLabel: string,
+		label: string,
+		text: string,
+		status: HarnessStatus = "wait",
+		details?: string[],
+	): void {
+		const next = { id: label, label, text, status, details };
+		const existing = this.messages.findIndex((message) => message.id === label);
+		if (existing !== -1) this.messages.splice(existing, 1);
+		const anchor = this.messages.findIndex((message) => message.id === anchorLabel);
+		if (anchor === -1) {
+			// Without the anchor there is nothing to be next to - the row
+			// goes to the end instead of being lost.
+			this.messages.push(next);
+		} else {
+			this.messages.splice(anchor + 1, 0, next);
+		}
+		this.onChange?.();
+	}
 }
 
 export function harnessStatusMarker(status: HarnessStatus): string {
-	return { wait: "[WAIT]", ok: "[OK]", warn: "[WARN]", err: "[ERR]" }[status];
+	return { wait: "[WAIT]", ok: "[OK]", info: "[INFO]", warn: "[WARN]", err: "[ERR]" }[status];
 }

package/index.ts

@@ -19,7 +19,7 @@ import type {
 	ExtensionCommandContext,
 	ExtensionContext,
 } from "@earendil-works/pi-coding-agent";
-import { HarnessStartupStatus, harnessStatusMarker } from "./harness-startup-status.ts";
+import { HarnessStartupStatus, harnessStatusMarker, type HarnessStatus } from "./harness-startup-status.ts";
 import {
 	auditKeyFiles,
 	fallbackKeyFileFixes,
@@ -38,6 +38,8 @@ import {
 	relayEndpointReport,
 	relayShouldBeReported,
 } from "./harness/startup-report.ts";
+import { localSkillsReport, skillsReport } from "./harness/skills-startup.ts";
+import { isChannelDisabled, setChannelDisabled } from "./harness/notification-settings.ts";
 import { UsageTracker } from "./tracker.ts";
 import { MirrorStore, type MirrorRecord } from "./mirror.ts";
 import { MiniMaxQuotaScraper } from "./harness/e2e/minimax-quota-scraper.js";
@@ -2102,7 +2104,14 @@ async function initTelegram(pi: ExtensionAPI): Promise<void> {
 			if (center.isChannelHealthy("line")) {
 				lineChannelState = "started";
 				lineChannelDiagnostic = null;
-				addHarnessMessage("LINE", "configured and enabled (tap Toggle LINE to disable)", "ok");
+				// The LINE line belongs directly after the Telegram line: the
+				// two notification channels are one topic.
+				addHarnessMessageAfter(
+					"Telegram",
+					"LINE",
+					"configured and enabled (tap Toggle LINE to disable)",
+					"ok",
+				);
 			} else {
 				lineChannelState = "failed";
 				// Keep the reason: "the token is wrong" and "LINE is down"
@@ -2199,8 +2208,14 @@ async function initTelegram(pi: ExtensionAPI): Promise<void> {
 					} else if (parsed.action === "toggle_line") {
 						const lineEnabled = (center as any).isChannelEnabled?.("line") ?? true;
 						(center as any).setChannelEnabled?.("line", !lineEnabled);
+						// The decision must survive a restart: the startup
+						// summary has to know that the channel was turned off
+						// on purpose.
+						persistChannelDecision("line", !lineEnabled);
 						logToFile("[TelegramCallback]", `LINE ${!lineEnabled ? "enabled" : "disabled"}`);
 						await acknowledge(`LINE notifications ${!lineEnabled ? "enabled" : "disabled"}`);
+						// The startup line must tell the truth.
+						reportLineConfiguration();
 					} else {
 						logToFile("[TelegramCallback]", `Unknown action: ${parsed.action}`);
 					}
@@ -2223,8 +2238,14 @@ async function initTelegram(pi: ExtensionAPI): Promise<void> {
 					const targetChannels = channel === "all" ? ["telegram", "line"] : [channel];
 					for (const ch of targetChannels) {
 						(center as any).setChannelEnabled?.(ch, isEnabled);
+						// The decision must survive a restart.
+						persistChannelDecision(ch, isEnabled);
 						logToFile("[NotifySettings]", `Set ${ch} to ${isEnabled ? "enabled" : "disabled"}`);
 					}
+					if (targetChannels.includes("line")) {
+						// The startup line must tell the truth.
+						reportLineConfiguration();
+					}
 				}
 
 				// Show current status
@@ -2506,6 +2527,48 @@ function reportRelayConfiguration(): void {
 	addHarnessMessage(report.label, report.text, report.status, report.details);
 }
 
+/**
+ * Put a startup line directly after another one.
+ *
+ * The notification channels belong together: the Telegram line and the LINE
+ * line must not be separated by a line that another feature added in
+ * between.
+ */
+function addHarnessMessageAfter(
+	anchorLabel: string,
+	label: string,
+	text: string,
+	status: HarnessStatus = "wait",
+	details?: string[],
+): void {
+	startupStatus.updateAfter(anchorLabel, label, text, status, details);
+}
+
+/**
+ * Remember an explicit channel decision.
+ *
+ * The notification center keeps the state in memory (and in its own
+ * database). The startup summary needs the decision BEFORE any channel is
+ * initialized, and it must survive a restart - so it is written to the
+ * notification settings.
+ */
+function persistChannelDecision(channel: string, enabled: boolean): void {
+	if (!setChannelDisabled(channel, !enabled)) {
+		logToFile("[NotifySettings]", `Could not persist the ${channel} decision`);
+	}
+}
+
+/**
+ * Did the user explicitly turn the LINE channel off?
+ *
+ * Only an explicit decision counts. A missing key file means the channel
+ * was never configured - that is a different state with a different
+ * meaning, and it must not be shown as "disabled".
+ */
+function lineIsExplicitlyDisabled(): boolean {
+	return isChannelDisabled("line");
+}
+
 /**
  * Report the LINE configuration in the startup summary.
  *
@@ -2514,20 +2577,23 @@ function reportRelayConfiguration(): void {
  * configured - that is exactly the fresh-install case where the user needs
  * the instructions. The "configured" line stays with initTelegram, which owns
  * the channel.
+ *
+ * The line is always reported: a fresh install must show that LINE is one
+ * of the two notification channels, together with the steps that make it
+ * work.
  */
 function reportLineConfiguration(): void {
-	// A user who never touched LINE must not see a warning on every start.
-	// The line appears as soon as a LINE client key file exists.
 	const report = lineConfigurationReport({
 		audit: getKeyFileAudit(),
-		clientKeyFilePresent: hasLineClientKeyFile(),
+		// An explicit opt-out is the only thing that makes the channel
+		// "disabled".
+		disabled: lineIsExplicitlyDisabled(),
 		channelState: lineChannelState,
 		telegramConfigured: telegramIsConfigured(),
-		// The fallback makes sure that a warning always carries a command,
-		// even when the audit could not answer. It names the ACCESS TOKEN
-		// only - the user id is the recipient of the messages, not the cause
-		// of a failed startup check.
-		fixes: keyFileFixesOrFallback("LINE", ["channel access token"]),
+		// Both credentials are named: a LINE channel needs the access token
+		// AND the user id. The fallback makes sure that a warning always
+		// carries a command, even when the audit could not answer.
+		fixes: keyFileFixesOrFallback("LINE", ["channel access token", "user id"]),
 		// The startup check validates the access token - the user id is only
 		// the recipient, so it must not be named as the cause.
 		accessTokenFixes: keyFileFixesOrFallback("LINE", ["channel access token"]),
@@ -2538,7 +2604,7 @@ function reportLineConfiguration(): void {
 		telegramFixes: keyFileFixesOrFallback("Telegram", ["bot token", "chat id"]),
 	});
 	if (!report) return;
-	addHarnessMessage(report.label, report.text, report.status, report.details);
+	addHarnessMessageAfter("Telegram", report.label, report.text, report.status, report.details);
 }
 
 /**
@@ -2576,24 +2642,6 @@ function hasAnyRelayKeyFile(): boolean {
 	}
 }
 
-/**
- * Does the key directory hold a LINE client credential?
- *
- * The LINE warning is only relevant for a user who started to set LINE up
- * (a line-access-token.txt or a line-user-id.txt file exists) but did not
- * finish. The channel secret (line-channel-secret.txt) does not count: it
- * is only needed on the host that runs the webhook server.
- */
-function hasLineClientKeyFile(): boolean {
-	try {
-		return readdirSync(harnessKeysDir()).some(
-			(entry) => entry === "line-access-token.txt" || entry === "line-user-id.txt",
-		);
-	} catch {
-		return false;
-	}
-}
-
 /**
  * Initialize relay streaming for real-time callback delivery.
  * Connects to the relay WebSocket server and forwards Telegram callbacks
@@ -3416,8 +3464,54 @@ async function initHermesSkills(pi: ExtensionAPI): Promise<void> {
 
 		// Scan skills from default locations
 		const result = initSkills();
-		logStartup(`[pi-harness] Scanned ${result.skills.length} skills`);
-		addHarnessMessage("Skills", `${result.skills.length} discovered`, "ok");
+		const localCount = result.skills.length;
+		logStartup(`[pi-harness] Scanned ${localCount} local skills`);
+		// The line carries the local count AND the count of the vector
+		// store: a machine without local skill files can still reach a
+		// shared skill, and a single "N discovered" hides that difference.
+		const local = localSkillsReport(localCount);
+		addHarnessMessage("Skills", local.text, local.status, local.details);
+		// The server-held skills. The service holds the authoritative
+		// files, so a machine without a local copy can still use a skill.
+		// It is only used when it is configured - a client without a
+		// service never calls out.
+		let remoteConfigured = false;
+		try {
+			const { isSkillSyncConfigured } = await import(
+				"./harness/skill-sync.js"
+			);
+			remoteConfigured = isSkillSyncConfigured();
+			if (remoteConfigured) {
+				const { SkillServiceSource } = await import(
+					"./harness/skill-remote-source.js"
+				);
+				result.registry.setRemoteSource(new SkillServiceSource());
+			}
+		} catch (err) {
+			logStartup(
+				`[pi-harness] Could not prepare the skill service: ${err instanceof Error ? err.message : String(err)}`,
+			);
+		}
+
+		// The count of the vector store needs the cluster, so it is fetched
+		// in the background - the startup must not wait for the network.
+		void (async () => {
+			const stats = await result.registry.getQdrantStats();
+			// The service is asked for its own state, so a refused
+			// service and an unreachable one stay apart.
+			const remote = remoteConfigured
+				? await result.registry.getRemoteStats().catch(() => ({
+						state: "unavailable" as const,
+						count: 0,
+					}))
+				: undefined;
+			const report = skillsReport(localCount, stats, remote);
+			addHarnessMessage("Skills", report.text, report.status, report.details);
+		})().catch((err) => {
+			logStartup(
+				`[pi-harness] Could not read the skill vector store: ${err instanceof Error ? err.message : String(err)}`,
+			);
+		});
 
 		// Register /skill commands
 		try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-harness-runtime",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "[BETA] Codex-style /usage status + autonomous coding harness for pi. Not production ready — expect breaking changes.",
   "type": "module",
   "scripts": {

package/packages/a2a-adapter/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/a2a-adapter",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "type": "module",
   "description": "Google Agent-to-Agent (A2A) protocol adapter for pi-harness",
   "main": "dist/index.js",

package/packages/agent-policy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/agent-policy",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Agent policy runtime for pi-harness - enforces mandatory rule delivery and mutation gating",
   "type": "module",
   "main": "./dist/index.js",

package/packages/architecture-generator/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/architecture-generator",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Generate ADR and Mermaid diagrams from project analysis",
   "type": "module",
   "main": "./dist/index.js",

package/packages/auth/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-harness/auth",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "pi-harness-runtime — auth",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-refactor/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-refactor",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "type": "module",
   "description": "Autonomous refactoring engine",
   "main": "dist/index.js",

package/packages/autonomous-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi/autonomous-runtime",
-  "version": "1.1.410",
+  "version": "1.1.412",
   "description": "Autonomous Operations Runtime — task inbox, lease management, and worker lifecycle (RFC-0101)",
   "type": "module",
   "main": "./dist/index.js",

package/packages/autonomous-runtime/test/types.test.ts

@@ -1,26 +1,29 @@
+/// <reference types="bun-types" />
 /**
  * Tests for autonomous-runtime types.
  */
 
 import { describe, it, expect } from "bun:test";
 import type {
-	TaskSpec,
 	TaskStatus,
 	TaskEvent,
 	TaskRecord,
-	LeaseStatus,
-	WorkerStatus,
+	TaskLease,
+	WorkerHeartbeat,
 } from "../src/types.js";
 
-describe("TaskStatus enum", () => {
+describe("TaskStatus", () => {
 	it("has all expected values", () => {
 		const values: TaskStatus[] = [
-			"pending",
+			"queued",
 			"claimed",
 			"running",
+			"waiting_approval",
+			"waiting_quota",
+			"retrying",
 			"completed",
 			"failed",
-			"cancelled",
+			"dead_letter",
 		];
 		for (const v of values) {
 			expect(typeof v).toBe("string");
@@ -28,41 +31,65 @@ describe("TaskStatus enum", () => {
 	});
 });
 
-describe("LeaseStatus enum", () => {
-	it("has all expected values", () => {
-		const values: LeaseStatus[] = [
-			"active",
-			"renewed",
-			"released",
-			"expired",
-		];
-		for (const v of values) {
-			expect(typeof v).toBe("string");
-		}
+describe("TaskEvent", () => {
+	it("accepts a minimal valid event", () => {
+		const event: TaskEvent = {
+			ts: new Date().toISOString(),
+			kind: "started",
+		};
+		expect(event.kind).toBe("started");
+		expect(typeof event.ts).toBe("string");
 	});
 });
 
-describe("TaskSpec", () => {
-	it("accepts a minimal valid spec", () => {
-		const spec: TaskSpec = {
+describe("TaskRecord", () => {
+	it("accepts a minimal valid record", () => {
+		const now = new Date().toISOString();
+		const record: TaskRecord = {
 			id: "task-1",
-			kind: "once",
-			priority: 5,
-			spec: {},
+			objective: "Do the thing",
+			acceptanceCriteria: ["it is done"],
+			source: { kind: "manual", createdBy: "test" },
+			priority: 2,
+			capabilities: [],
+			approvalClass: "automatic_read_only",
+			status: "queued",
+			attempts: 0,
+			maxAttempts: 3,
+			createdAt: now,
+			updatedAt: now,
+			history: [],
+		};
+		expect(record.id).toBe("task-1");
+		expect(record.status).toBe("queued");
+	});
+});
+
+describe("TaskLease", () => {
+	it("accepts a valid lease", () => {
+		const now = new Date().toISOString();
+		const lease: TaskLease = {
+			taskId: "task-1",
+			workerId: "worker-1",
+			acquiredAt: now,
+			expiresAt: now,
+			heartbeatAt: now,
+			attempt: 1,
 		};
-		expect(spec.id).toBe("task-1");
-		expect(spec.kind).toBe("once");
-		expect(spec.priority).toBe(5);
+		expect(lease.workerId).toBe("worker-1");
 	});
 });
 
-describe("WorkerStatus", () => {
-	it("accepts a valid status", () => {
-		const status: WorkerStatus = {
+describe("WorkerHeartbeat", () => {
+	it("accepts a valid heartbeat", () => {
+		const now = new Date().toISOString();
+		const heartbeat: WorkerHeartbeat = {
 			workerId: "worker-1",
-			running: true,
-			heartbeatIntervalMs: 30_000,
+			startedAt: now,
+			lastBeatAt: now,
+			capacity: 2,
+			inflightTaskIds: [],
 		};
-		expect(status.running).toBe(true);
+		expect(heartbeat.workerId).toBe("worker-1");
 	});
 });