pi-crew 0.9.26 → 0.9.28

package/src/extension/crew-vibes/speed.ts

@@ -0,0 +1,286 @@
+import type { SpeedConfig } from "./config.ts";
+
+/**
+ * Token-speed engine ported from pi-speeed (MIT, attribution in NOTICE.md).
+ * Tracks output tok/s with a sliding window and suppresses unreliable
+ * burst-only readings. No stats/font handling — just the live + session avg.
+ */
+
+export type TokenEvent = { time: number; tokens: number };
+
+const COMPACTION_THRESHOLD = 5000;
+
+export type EngineConfig = Pick<SpeedConfig, "slidingWindowMs" | "minReliableDurationMs" | "maxDisplayTokS">;
+
+export function estimateTokensFromDelta(text: string): number {
+	if (!text) return 0;
+	const matches = text.match(/\w+|[^\s\w]/g);
+	return matches ? matches.length : 0;
+}
+
+export class TokenSpeedEngine {
+	private _isStreaming = false;
+	private _tokenCount = 0;
+	private _startTime = 0;
+	private _endTime = 0;
+	private _events: TokenEvent[] = [];
+	private _windowStartIndex = 0;
+	private _lastStableTokS = 0;
+	private _lastUsageOutput = 0;
+	private _config: EngineConfig;
+
+	constructor(config: EngineConfig) {
+		this._config = config;
+	}
+
+	updateConfig(config: EngineConfig): void {
+		this._config = config;
+	}
+
+	get isStreaming(): boolean {
+		return this._isStreaming;
+	}
+
+	get tokenCount(): number {
+		return this._tokenCount;
+	}
+
+	get elapsedMs(): number {
+		if (this._startTime === 0) return 0;
+		return this._isStreaming ? Date.now() - this._startTime : this._endTime - this._startTime;
+	}
+
+	get avgTokS(): number {
+		const elapsedSec = this.elapsedMs / 1000;
+		if (elapsedSec <= 0) return 0;
+		return this._tokenCount / elapsedSec;
+	}
+
+	sanitizeTokS(value: number | null, durationMs = this.elapsedMs): number | null {
+		if (value === null || !Number.isFinite(value) || value <= 0) return null;
+		if (durationMs < this._config.minReliableDurationMs) return null;
+		if (value > this._config.maxDisplayTokS) return null;
+		return value;
+	}
+
+	get tokS(): number {
+		const candidate = this.rawTokS;
+		const stable = this.sanitizeTokS(candidate);
+		if (stable !== null) this._lastStableTokS = stable;
+		return this._lastStableTokS;
+	}
+
+	get rawTokS(): number {
+		if (this.elapsedMs < this._config.slidingWindowMs) return this.avgTokS;
+		if (!this._isStreaming) return this.avgTokS;
+
+		const now = Date.now();
+		const windowStart = now - this._config.slidingWindowMs;
+
+		while (this._windowStartIndex < this._events.length && this._events[this._windowStartIndex].time < windowStart) {
+			this._windowStartIndex++;
+		}
+
+		if (this._windowStartIndex >= this._events.length) return this.avgTokS;
+
+		let windowTokenCount = 0;
+		for (let i = this._windowStartIndex; i < this._events.length; i++) {
+			windowTokenCount += this._events[i].tokens;
+		}
+		if (windowTokenCount === 0) return this.avgTokS;
+
+		const windowDuration = (now - this._events[this._windowStartIndex].time) / 1000;
+		if (windowDuration <= 0) return 0;
+
+		return windowTokenCount / windowDuration;
+	}
+
+	start(): void {
+		this._tokenCount = 0;
+		this._isStreaming = true;
+		this._startTime = Date.now();
+		this._endTime = this._startTime;
+		this._events = [];
+		this._windowStartIndex = 0;
+		this._lastStableTokS = 0;
+		this._lastUsageOutput = 0;
+	}
+
+	stop(): void {
+		this._isStreaming = false;
+		this._endTime = Date.now();
+		this._events = [];
+		this._windowStartIndex = 0;
+	}
+
+	recordDelta(delta: string, usageOutput?: number): void {
+		if (!this._isStreaming) return;
+		if (usageOutput !== undefined && usageOutput > 0) {
+			// usageOutput may be cumulative across message_update events. Track the
+			// delta to avoid inflating _tokenCount by N× the true total.
+			const increment = usageOutput - this._lastUsageOutput;
+			this._lastUsageOutput = usageOutput;
+			this.recordTokens(Math.max(0, increment));
+			return;
+		}
+		this.recordTokens(estimateTokensFromDelta(delta));
+	}
+
+	reconcileTotal(tokens: number): void {
+		if (tokens > 0) this._tokenCount = tokens;
+	}
+
+	recordTokens(tokens: number): void {
+		if (!this._isStreaming || tokens <= 0) return;
+		this._tokenCount += tokens;
+		this._events.push({ time: Date.now(), tokens });
+		if (this._windowStartIndex >= COMPACTION_THRESHOLD) this.compact();
+	}
+
+	private compact(): void {
+		if (this._windowStartIndex === 0) return;
+		this._events = this._events.slice(this._windowStartIndex);
+		this._windowStartIndex = 0;
+	}
+}
+
+export type CompletedMessageSpeed = {
+	outputTokens: number;
+	durationMs: number;
+	tokS: number | null;
+};
+
+function isSuccessfulStop(stopReason: string | undefined): boolean {
+	return stopReason !== "error" && stopReason !== "aborted";
+}
+
+export class SpeedTracker {
+	private readonly engine: TokenSpeedEngine;
+	private lastStableTokS: number | null = null;
+	private sessionOutputTokens = 0;
+	private sessionDurationMs = 0;
+
+	constructor(config: SpeedConfig) {
+		this.engine = new TokenSpeedEngine(config);
+	}
+
+	updateConfig(config: SpeedConfig): void {
+		this.engine.updateConfig(config);
+	}
+
+	get isStreaming(): boolean {
+		return this.engine.isStreaming;
+	}
+
+	get lastTokS(): number | null {
+		return this.lastStableTokS;
+	}
+
+	resetSession(): void {
+		this.sessionOutputTokens = 0;
+		this.sessionDurationMs = 0;
+	}
+
+	startMessage(): void {
+		this.engine.start();
+	}
+
+	recordDelta(delta: string, usageOutput?: number): void {
+		this.engine.recordDelta(delta, usageOutput);
+	}
+
+	stopMessage(): void {
+		if (this.engine.isStreaming) this.engine.stop();
+	}
+
+	liveTokS(): number | null {
+		const speed = this.engine.tokS;
+		return speed > 0 ? speed : this.lastStableTokS;
+	}
+
+	sessionAvgTokS(): number | null {
+		return this.sessionDurationMs > 0 ? this.sessionOutputTokens / (this.sessionDurationMs / 1000) : null;
+	}
+
+	finishMessage(outputTokens: number, stopReason: string | undefined): CompletedMessageSpeed | null {
+		if (!this.engine.isStreaming) return null;
+
+		this.engine.reconcileTotal(outputTokens);
+		const durationMs = this.engine.elapsedMs;
+		const tokens = this.engine.tokenCount;
+		const rawAvgTokS = durationMs > 0 ? tokens / (durationMs / 1000) : null;
+		const tokS = this.engine.sanitizeTokS(rawAvgTokS, durationMs);
+		this.lastStableTokS = tokS;
+		this.engine.stop();
+
+		if (tokS !== null && isSuccessfulStop(stopReason)) {
+			this.sessionOutputTokens += tokens;
+			this.sessionDurationMs += durationMs;
+		}
+
+		return { outputTokens: tokens, durationMs, tokS };
+	}
+}
+
+export class SpeedAnimator {
+	private from: number | null = null;
+	private target: number | null = null;
+	private startedAt = 0;
+	private durationMs: number;
+
+	constructor(durationMs: number) {
+		this.durationMs = durationMs;
+	}
+
+	updateDuration(durationMs: number): void {
+		this.durationMs = durationMs;
+	}
+
+	reset(value: number | null = null, now = Date.now()): void {
+		this.from = value;
+		this.target = value;
+		this.startedAt = now;
+	}
+
+	setTarget(target: number | null, now = Date.now()): number | null {
+		if (target === null) {
+			this.reset(null, now);
+			return null;
+		}
+
+		const current = this.value(now);
+		if (current === null) {
+			this.reset(target, now);
+			return target;
+		}
+
+		if (this.target !== null && Math.abs(target - this.target) < 0.05) return current;
+
+		this.from = current;
+		this.target = target;
+		this.startedAt = now;
+		return current;
+	}
+
+	value(now = Date.now()): number | null {
+		if (this.target === null) return null;
+		if (this.from === null || this.durationMs <= 0) return this.target;
+
+		const progress = Math.max(0, Math.min(1, (now - this.startedAt) / this.durationMs));
+		if (progress >= 1) {
+			this.from = this.target;
+			return this.target;
+		}
+
+		return this.from + (this.target - this.from) * progress;
+	}
+
+	isAnimating(now = Date.now()): boolean {
+		return (
+			this.target !== null &&
+			this.from !== null &&
+			Math.abs(this.target - this.from) >= 0.05 &&
+			now - this.startedAt < this.durationMs
+		);
+	}
+}

package/src/extension/knowledge-injection.ts

@@ -22,6 +22,7 @@
  */
 import * as fs from "node:fs";
 import * as path from "node:path";
+import { logInternalError } from "../utils/internal-error.ts";
 import { projectCrewRoot } from "../utils/paths.ts";
 import type { BeforeAgentStartEvent, ExtensionAPI } from "./pi-api.ts";
 
@@ -259,6 +260,13 @@ export function readKnowledge(cwd: string, query?: KnowledgeQuery): string {
 			knowledgeCache.delete(p);
 			return "";
 		}
+		// Security: reject symlinks to prevent information disclosure.
+		// An attacker could replace knowledge.md with a symlink to /etc/shadow
+		// or other sensitive files.
+		if (stat.isSymbolicLink) {
+			logInternalError("knowledge-injection.symlink", new Error(`Refusing to read symlink: ${p}`));
+			return "";
+		}
 		// P5 (Round 15): mtime+size cache. readKnowledge fires on every agent
 		// start (main session + every worker), re-reading the file each time.
 		// For a run with N workers this is N redundant readFileSync of the same
@@ -322,10 +330,11 @@ export function readKnowledge(cwd: string, query?: KnowledgeQuery): string {
 }
 
 /** Stat helper returning undefined on error (file missing, perms, etc.). */
-function tryStat(p: string): { mtimeMs: number; size: number } | undefined {
+function tryStat(p: string): { mtimeMs: number; size: number; isSymbolicLink: boolean } | undefined {
 	try {
-		const s = fs.statSync(p);
-		return { mtimeMs: s.mtimeMs, size: s.size };
+		// Use lstatSync to detect symlinks (statSync follows them).
+		const s = fs.lstatSync(p);
+		return { mtimeMs: s.mtimeMs, size: s.size, isSymbolicLink: s.isSymbolicLink() };
 	} catch {
 		return undefined;
 	}

package/src/extension/management.ts

@@ -3,21 +3,32 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import type { AgentConfig, ResourceSource, RoutingMetadata } from "../agents/agent-config.ts";
 import { serializeAgent } from "../agents/agent-serializer.ts";
-import { discoverAgents } from "../agents/discover-agents.ts";
+import { discoverAgents, invalidateAgentDiscoveryCache } from "../agents/discover-agents.ts";
 import type { PiTeamsConfig } from "../config/config.ts";
 import type { TeamToolParamsValue } from "../schema/team-tool-schema.ts";
-import { allTeams, discoverTeams } from "../teams/discover-teams.ts";
+import { allTeams, discoverTeams, invalidateTeamDiscoveryCache } from "../teams/discover-teams.ts";
 import type { TeamConfig, TeamRole } from "../teams/team-config.ts";
 import { serializeTeam } from "../teams/team-serializer.ts";
 import { hasOwn, parseConfigObject, requireString, sanitizeName } from "../utils/names.ts";
 import { projectCrewRoot, userPiRoot } from "../utils/paths.ts";
-import { allWorkflows, discoverWorkflows } from "../workflows/discover-workflows.ts";
+import { allWorkflows, discoverWorkflows, invalidateWorkflowDiscoveryCache } from "../workflows/discover-workflows.ts";
 import type { WorkflowConfig, WorkflowStep } from "../workflows/workflow-config.ts";
 import { serializeWorkflow } from "../workflows/workflow-serializer.ts";
 import { enforceDestructiveIntent } from "./team-tool/intent-policy.ts";
 import type { TeamToolDetails } from "./team-tool-types.ts";
 import { type PiTeamsToolResult, toolResult } from "./tool-result.ts";
 
+/**
+ * Invalidate all discovery caches that may have read the on-disk resource
+ * file we are about to (or just did) write. Called once per create/update/delete
+ * to keep the 5 s TTL caches in sync without forcing a per-render full rescan.
+ */
+function invalidateResourceCaches(): void {
+	invalidateAgentDiscoveryCache();
+	invalidateTeamDiscoveryCache();
+	invalidateWorkflowDiscoveryCache();
+}
+
 interface ManagementContext {
 	cwd: string;
 	config?: PiTeamsConfig;
@@ -385,6 +396,9 @@ export function handleCreate(params: TeamToolParamsValue, ctx: ManagementContext
 			true,
 		);
 	}
+	// F17/F15: bust the discovery caches so future powerbar/scheduler reads see
+	// the new file immediately (instead of after the 5 s TTL expires).
+	invalidateResourceCaches();
 	return result(`Created ${params.resource} '${name}' at ${filePath}.`);
 }
 
@@ -507,9 +521,13 @@ export function handleUpdate(params: TeamToolParamsValue, ctx: ManagementContext
 			true,
 		);
 	}
+	// F17/F15: bust the discovery caches so the renamed/updated resource is
+	// visible immediately. updateReferencesForRename may have rewritten peer
+	// files too, so we invalidate AFTER that pass completes.
 	const updatedRefs = params.updateReferences
 		? updateReferencesForRename(ctx, params.resource!, current.name, nextName, source, false)
 		: [];
+	invalidateResourceCaches();
 	return result(
 		[
 			`Updated ${params.resource} at ${nextPath}. Backup: ${backupPath}.`,
@@ -546,5 +564,7 @@ export function handleDelete(params: TeamToolParamsValue, ctx: ManagementContext
 			true,
 		);
 	}
+	// F17/F15: bust the discovery caches so the deletion is visible immediately.
+	invalidateResourceCaches();
 	return result(`Deleted ${params.resource} at ${resolved.resource!.filePath}. Backup: ${backupPath}.`);
 }

package/src/extension/register.ts

@@ -64,6 +64,7 @@ import { registerCrewAutocomplete } from "./crew-autocomplete.ts";
 import { registerCleanupHandler } from "./crew-cleanup.ts";
 import { registerCrewInputRouter } from "./crew-input-router.ts";
 import { registerCrewShortcuts } from "./crew-shortcuts.ts";
+import { registerCrewVibes } from "./crew-vibes/index.ts";
 import { type PiCrewRpcHandle, registerPiCrewRpc } from "./cross-extension-rpc.ts";
 import { registerKnowledgeInjection } from "./knowledge-injection.ts";
 import { registerCrewMessageRenderers } from "./message-renderers.ts";
@@ -1545,4 +1546,10 @@ export function registerPiTeams(pi: ExtensionAPI): void {
 	registerContextStatusInjection(pi, {
 		enabled: loadConfig(process.cwd()).config.reliability?.ambientStatusInjection !== false,
 	});
+
+	try {
+		registerCrewVibes(pi);
+	} catch (err) {
+		console.warn("[pi-crew] crew-vibes initialization failed:", err instanceof Error ? err.message : err);
+	}
 }

package/src/extension/team-tool.ts

@@ -498,6 +498,17 @@ export function handleSteer(params: TeamToolParamsValue, ctx: TeamContext): PiTe
 	}
 	task.pendingSteers.push(message);
 	saveRunTasks(loaded.manifest, loaded.tasks);
+	// Real-time steer delivery: write to steering file so child can read immediately
+	try {
+		const steeringDir = `${loaded.manifest.artifactsRoot}/steering`;
+		fs.mkdirSync(steeringDir, { recursive: true });
+		fs.appendFileSync(
+			`${steeringDir}/${taskId}.jsonl`,
+			JSON.stringify({ type: "steer", message, ts: new Date().toISOString() }) + "\n",
+		);
+	} catch {
+		// Best-effort: file write failure doesn't block the steer from pending array
+	}
 	appendEvent(loaded.manifest.eventsPath, {
 		type: "task.steer_queued",
 		runId,

package/src/prompt/prompt-runtime.ts

@@ -1,9 +1,12 @@
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import * as fs from "node:fs";
 
 export const PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV = "PI_TEAMS_INHERIT_PROJECT_CONTEXT";
 export const PI_TEAMS_INHERIT_SKILLS_ENV = "PI_TEAMS_INHERIT_SKILLS";
 export const PI_CREW_INHERIT_PROJECT_CONTEXT_ENV = "PI_CREW_INHERIT_PROJECT_CONTEXT";
 export const PI_CREW_INHERIT_SKILLS_ENV = "PI_CREW_INHERIT_SKILLS";
+const PI_CREW_MAX_OUTPUT_ENV = "PI_CREW_MAX_OUTPUT";
+const PI_CREW_STEERING_FILE_ENV = "PI_CREW_STEERING_FILE";
 
 const PROJECT_CONTEXT_HEADER = "\n\n# Project Context\n\nProject-specific instructions and guidelines:\n\n";
 const SKILLS_HEADER = "\n\nThe following skills provide specialized instructions for specific tasks.";
@@ -58,6 +61,68 @@ export function rewriteTeamWorkerPrompt(prompt: string, options: { inheritProjec
 }
 
 export default function registerPiTeamsPromptRuntime(pi: ExtensionAPI): void {
+	// ── Feature 1: maxTokens cap ──────────────────────────────────────────
+	// Cap output tokens per API call for background workers. Reads
+	// PI_CREW_MAX_OUTPUT_TOKENS env (set by pi-args.ts from agent.maxTokens).
+	const maxTokensEnv = process.env[PI_CREW_MAX_OUTPUT_ENV];
+	const maxTokensCap = maxTokensEnv ? Number.parseInt(maxTokensEnv, 10) : undefined;
+	if (maxTokensCap && maxTokensCap > 0) {
+		pi.on("before_provider_request", (event) => {
+			const payload = event.payload as Record<string, unknown> | undefined;
+			if (!payload || typeof payload !== "object") return;
+			// Cap both OpenAI-style max_tokens and Anthropic-style max_tokens
+			if (typeof payload.max_tokens === "number" && payload.max_tokens > maxTokensCap) {
+				payload.max_tokens = maxTokensCap;
+			}
+		});
+	}
+
+	// ── Feature 2: real-time steering ──────────────────────────────────────
+	// Poll the steering JSONL file for new steer messages. The parent (team
+	// tool) writes steers here in real-time; this reader injects them into
+	// the active session via pi.sendMessage with deliverAs:"steer".
+	const steeringFile = process.env[PI_CREW_STEERING_FILE_ENV];
+	if (steeringFile) {
+		let lastOffset = 0;
+		const pollSteering = (): void => {
+			try {
+				const stat = fs.statSync(steeringFile, { throwIfNoEntry: false });
+				if (!stat || stat.size <= lastOffset) return;
+				const fd = fs.openSync(steeringFile, "r");
+				try {
+					const buf = Buffer.alloc(stat.size - lastOffset);
+					fs.readSync(fd, buf, 0, buf.length, lastOffset);
+					lastOffset = stat.size;
+					const lines = buf.toString("utf8").split("\n").filter(Boolean);
+					for (const line of lines) {
+						try {
+							const entry = JSON.parse(line) as { type?: string; message?: string };
+							if (entry.type === "steer" && entry.message) {
+								pi.sendMessage(
+									{ customType: "crew-steer", content: entry.message, display: false },
+									{ deliverAs: "steer" },
+								);
+							}
+						} catch {
+							// Malformed line — skip
+						}
+					}
+				} finally {
+					try {
+						fs.closeSync(fd);
+					} catch {
+						/* already closed */
+					}
+				}
+			} catch {
+				// File doesn't exist yet or read error — will retry next tick
+			}
+		};
+		const timer = setInterval(pollSteering, 500);
+		timer.unref?.();
+	}
+
+	// ── Prompt rewriting (existing) ────────────────────────────────────────
 	pi.on("before_agent_start", (event) => {
 		const inheritProjectContext = readBooleanEnvAny(PI_CREW_INHERIT_PROJECT_CONTEXT_ENV, PI_TEAMS_INHERIT_PROJECT_CONTEXT_ENV);
 		const inheritSkills = readBooleanEnvAny(PI_CREW_INHERIT_SKILLS_ENV, PI_TEAMS_INHERIT_SKILLS_ENV);