pi-crew 0.5.25 → 0.6.1

package/src/state/memory-store.ts

@@ -0,0 +1,244 @@
+/**
+ * 4-Tier Memory Consolidation System.
+ *
+ * Pattern origin: agentmemory — Working → Episodic → Semantic → Procedural.
+ * Ebbinghaus decay curve: S(t) = e^(-t/s) where s = strength.
+ * Frequently accessed memories strengthen. Tier promotion on access count.
+ * Token-budgeted injection for context window management.
+ *
+ * Tiers:
+ * - Working: Current run observations (capacity: 50)
+ * - Episodic: Recent run summaries (capacity: 200)
+ * - Semantic: Extracted patterns/knowledge (capacity: 1000)
+ * - Procedural: Learned skills/methods (capacity: 100)
+ */
+
+import { mkdirSync, readFileSync, writeFileSync, existsSync } from "node:fs";
+import { logInternalError } from "../utils/internal-error.ts";
+
+// ── Types ────────────────────────────────────────────────────────────────
+
+export type MemoryTier = "working" | "episodic" | "semantic" | "procedural";
+
+export interface Memory {
+	id: string;
+	tier: MemoryTier;
+	content: string;
+	strength: number;        // 0.0–1.0
+	accessCount: number;
+	lastAccessed: number;    // epoch ms
+	createdAt: number;       // epoch ms
+	tags: string[];
+	sourceRunId?: string;
+}
+
+export interface MemoryConfig {
+	workingCapacity: number;
+	episodicCapacity: number;
+	semanticCapacity: number;
+	proceduralCapacity: number;
+	decayRate: number;        // Ebbinghaus parameter (higher = faster decay)
+	tokenBudget: number;      // max tokens to inject
+}
+
+const DEFAULT_CONFIG: MemoryConfig = {
+	workingCapacity: 50,
+	episodicCapacity: 200,
+	semanticCapacity: 1000,
+	proceduralCapacity: 100,
+	decayRate: 0.001,         // slow decay
+	tokenBudget: 2000,
+};
+
+const TIER_CAPACITIES: Record<MemoryTier, keyof MemoryConfig> = {
+	working: "workingCapacity",
+	episodic: "episodicCapacity",
+	semantic: "semanticCapacity",
+	procedural: "proceduralCapacity",
+};
+
+// ── Memory Operations ────────────────────────────────────────────────────
+
+/**
+ * Compute current strength using Ebbinghaus decay.
+ * S(t) = strength * e^(-elapsed_ms * decayRate)
+ */
+export function computeCurrentStrength(memory: Memory, config = DEFAULT_CONFIG): number {
+	const elapsedMs = Date.now() - memory.lastAccessed;
+	return memory.strength * Math.exp(-elapsedMs * config.decayRate);
+}
+
+/**
+ * Access a memory — strengthens it and updates access count.
+ * After N accesses, memory may be promoted to a higher tier.
+ */
+export function accessMemory(memory: Memory): Memory {
+	const newCount = memory.accessCount + 1;
+
+	// Strengthen: capped at 1.0
+	const newStrength = Math.min(1.0, memory.strength + 0.1);
+
+	// Tier promotion thresholds
+	let newTier = memory.tier;
+	if (newCount >= 10 && memory.tier === "working") newTier = "episodic";
+	if (newCount >= 20 && memory.tier === "episodic") newTier = "semantic";
+	if (newCount >= 30 && memory.tier === "semantic") newTier = "procedural";
+
+	return {
+		...memory,
+		strength: newStrength,
+		accessCount: newCount,
+		lastAccessed: Date.now(),
+		tier: newTier,
+	};
+}
+
+/**
+ * Create a new working memory.
+ */
+export function createMemory(content: string, tags: string[] = [], sourceRunId?: string): Memory {
+	return {
+		id: `mem-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 6)}`,
+		tier: "working",
+		content,
+		strength: 0.5,
+		accessCount: 0,
+		lastAccessed: Date.now(),
+		createdAt: Date.now(),
+		tags,
+		sourceRunId,
+	};
+}
+
+// ── Memory Store ─────────────────────────────────────────────────────────
+
+export class MemoryStore {
+	private memories = new Map<string, Memory>();
+	private config: MemoryConfig;
+	private storePath?: string;
+
+	constructor(config: Partial<MemoryConfig> = {}, storePath?: string) {
+		this.config = { ...DEFAULT_CONFIG, ...config };
+		this.storePath = storePath;
+		if (storePath && existsSync(storePath)) {
+			this.load();
+		}
+	}
+
+	/**
+	 * Add a memory to the store, enforcing capacity limits.
+	 */
+	add(memory: Memory): void {
+		// Evict weakest if at capacity
+		const capacity = this.config[TIER_CAPACITIES[memory.tier]];
+		const tierMemories = [...this.memories.values()].filter((m) => m.tier === memory.tier);
+
+		if (tierMemories.length >= capacity) {
+			// Evict weakest memory in this tier
+			const weakest = tierMemories
+				.map((m) => ({ id: m.id, strength: computeCurrentStrength(m, this.config) }))
+				.sort((a, b) => a.strength - b.strength)[0];
+			if (weakest) this.memories.delete(weakest.id);
+		}
+
+		this.memories.set(memory.id, memory);
+	}
+
+	/**
+	 * Search memories by tags, returning strongest matches first.
+	 */
+	search(query: string, tags: string[] = [], limit = 10): Memory[] {
+		const queryLower = query.toLowerCase();
+
+		let results = [...this.memories.values()]
+			// Apply decay
+			.map((m) => ({ ...m, strength: computeCurrentStrength(m, this.config) }))
+			// Filter by minimum strength
+			.filter((m) => m.strength > 0.1)
+			// Score relevance
+			.map((m) => {
+				let score = m.strength;
+				if (m.content.toLowerCase().includes(queryLower)) score += 0.3;
+				if (tags.some((t) => m.tags.includes(t))) score += 0.2;
+				return { ...m, strength: score };
+			})
+			.sort((a, b) => b.strength - a.strength)
+			.slice(0, limit);
+
+		// Access side effect: strengthen returned memories
+		results = results.map((m) => accessMemory(m));
+		for (const m of results) {
+			this.memories.set(m.id, m);
+		}
+
+		return results;
+	}
+
+	/**
+	 * Inject memories into a prompt within a token budget.
+	 * Returns formatted text block.
+	 */
+	inject(query: string, tags: string[] = []): string {
+		const results = this.search(query, tags, 20);
+
+		if (results.length === 0) return "";
+
+		// Estimate tokens (4 chars ≈ 1 token)
+		const budget = this.config.tokenBudget;
+		let usedTokens = 0;
+		const selected: Memory[] = [];
+
+		for (const memory of results) {
+			const tokens = Math.ceil(memory.content.length / 4);
+			if (usedTokens + tokens > budget) break;
+			selected.push(memory);
+			usedTokens += tokens;
+		}
+
+		if (selected.length === 0) return "";
+
+		return "## Relevant Context from Previous Runs\n\n" +
+			selected.map((m) => `- [${m.tier}] ${m.content}`).join("\n") +
+			"\n";
+	}
+
+	/**
+	 * Get count of memories per tier.
+	 */
+	get stats(): Record<MemoryTier, number> {
+		const counts: Record<MemoryTier, number> = { working: 0, episodic: 0, semantic: 0, procedural: 0 };
+		for (const m of this.memories.values()) {
+			counts[m.tier]++;
+		}
+		return counts;
+	}
+
+	/**
+	 * Persist memories to disk.
+	 */
+	save(): void {
+		if (!this.storePath) return;
+		const entries = [...this.memories.values()];
+		try {
+			mkdirSync(path.dirname(this.storePath), { recursive: true });
+			writeFileSync(this.storePath, JSON.stringify(entries, null, 2), "utf-8");
+		} catch (error) {
+			logInternalError("memory-store.save", error, `path=${this.storePath}`);
+		}
+	}
+
+	private load(): void {
+		if (!this.storePath) return;
+		try {
+			const data = JSON.parse(readFileSync(this.storePath, "utf-8")) as Memory[];
+			for (const m of data) {
+				this.memories.set(m.id, m);
+			}
+		} catch (error) {
+			logInternalError("memory-store.load", error, `path=${this.storePath}`);
+		}
+	}
+}
+
+// Need path for mkdirSync in save()
+import path from "node:path";

package/src/state/observation-store.ts

@@ -0,0 +1,177 @@
+/**
+ * Observation capture and compression system.
+ *
+ * Pattern origin: claude-mem — captures tool usage across sessions,
+ * compresses via AI, injects into future sessions.
+ *
+ * This module provides the observation store and compression logic.
+ * Actual capture hooks into the lifecycle events (Pattern 12).
+ */
+
+import { mkdirSync, readFileSync, writeFileSync, existsSync, appendFileSync } from "node:fs";
+import { logInternalError } from "../utils/internal-error.ts";
+
+// ── Types ────────────────────────────────────────────────────────────────
+
+export interface Observation {
+	tool: string;
+	input: string;
+	output: string;
+	filesRead: string[];
+	filesModified: string[];
+	timestamp: number;
+	sessionId: string;
+	taskId?: string;
+}
+
+export interface CompressedObservation {
+	summary: string;
+	patterns: string[];
+	decisions: string[];
+	filesAffected: string[];
+	relevanceScore: number;
+	timestamp: number;
+	sessionId: string;
+}
+
+export interface ObservationStoreConfig {
+	maxObservations: number;
+	maxCompressed: number;
+	privacyTags: string[];  // tags to strip before storage
+}
+
+const DEFAULT_CONFIG: ObservationStoreConfig = {
+	maxObservations: 1000,
+	maxCompressed: 200,
+	privacyTags: ["<private>", "<secret>", "<credentials>"],
+};
+
+// ── Privacy ──────────────────────────────────────────────────────────────
+
+/**
+ * Strip privacy-tagged content from a string.
+ */
+export function stripPrivacyTags(content: string, config = DEFAULT_CONFIG): string {
+	let result = content;
+	for (const tag of config.privacyTags) {
+		const openTag = tag;
+		const closeTag = tag.replace("<", "</");
+		// Remove everything between open and close tags
+		const regex = new RegExp(`${escapeRegex(openTag)}[\\s\\S]*?${escapeRegex(closeTag)}`, "gi");
+		result = result.replace(regex, "[REDACTED]");
+	}
+	return result;
+}
+
+function escapeRegex(str: string): string {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ── Observation Store ────────────────────────────────────────────────────
+
+export class ObservationStore {
+	private observations: Observation[] = [];
+	private compressed: CompressedObservation[] = [];
+	private config: ObservationStoreConfig;
+	private storePath: string;
+
+	constructor(storePath: string, config: Partial<ObservationStoreConfig> = {}) {
+		this.config = { ...DEFAULT_CONFIG, ...config };
+		this.storePath = storePath;
+		if (existsSync(storePath)) {
+			this.load();
+		}
+	}
+
+	/**
+	 * Record a new observation.
+	 */
+	record(observation: Observation): void {
+		// Strip privacy
+		const sanitized: Observation = {
+			...observation,
+			input: stripPrivacyTags(observation.input, this.config),
+			output: stripPrivacyTags(observation.output, this.config),
+		};
+
+		this.observations.push(sanitized);
+
+		// Enforce capacity
+		if (this.observations.length > this.config.maxObservations) {
+			this.observations = this.observations.slice(-this.config.maxObservations);
+		}
+	}
+
+	/**
+	 * Get recent observations.
+	 */
+	getRecent(count = 10): Observation[] {
+		return this.observations.slice(-count);
+	}
+
+	/**
+	 * Store a compressed observation.
+	 */
+	addCompressed(compressed: CompressedObservation): void {
+		this.compressed.push(compressed);
+
+		if (this.compressed.length > this.config.maxCompressed) {
+			this.compressed = this.compressed.slice(-this.config.maxCompressed);
+		}
+	}
+
+	/**
+	 * Get compressed observations for injection.
+	 */
+	getCompressed(limit = 5): CompressedObservation[] {
+		return this.compressed
+			.sort((a, b) => b.relevanceScore - a.relevanceScore)
+			.slice(0, limit);
+	}
+
+	/**
+	 * Format compressed observations for prompt injection.
+	 */
+	injectCompressed(limit = 5): string {
+		const items = this.getCompressed(limit);
+		if (items.length === 0) return "";
+
+		return "## Observations from Previous Sessions\n\n" +
+			items.map((o) =>
+				`### ${o.summary}\n` +
+				`Patterns: ${o.patterns.join(", ")}\n` +
+				`Decisions: ${o.decisions.join(", ")}\n` +
+				`Files: ${o.filesAffected.join(", ")}`,
+			).join("\n\n") +
+			"\n";
+	}
+
+	/**
+	 * Persist to disk.
+	 */
+	save(): void {
+		try {
+			mkdirSync(this.storePath.substring(0, this.storePath.lastIndexOf("/")), { recursive: true });
+			writeFileSync(this.storePath, JSON.stringify({
+				observations: this.observations,
+				compressed: this.compressed,
+			}, null, 2), "utf-8");
+		} catch (error) {
+			logInternalError("observation-store.save", error, `path=${this.storePath}`);
+		}
+	}
+
+	get stats(): { observations: number; compressed: number } {
+		return { observations: this.observations.length, compressed: this.compressed.length };
+	}
+
+	private load(): void {
+		try {
+			const data = JSON.parse(readFileSync(this.storePath, "utf-8"));
+			if (Array.isArray(data.observations)) this.observations = data.observations;
+			if (Array.isArray(data.compressed)) this.compressed = data.compressed;
+		} catch (error) {
+			logInternalError("observation-store.load", error, `path=${this.storePath}`);
+		}
+	}
+}

package/src/state/state-store.ts

@@ -208,7 +208,8 @@ export function saveRunTasks(manifest: TeamRunManifest, tasks: TeamTaskState[]):
  * intended use case. Single-update + read-update loops (e.g.
  * persistSingleTaskUpdate) should keep using saveRunTasks.
  */
-export function saveRunTasksCoalesced(manifest: TeamRunManifest, tasks: TeamTaskState[]): void {
+/** @internal */
+function saveRunTasksCoalesced(manifest: TeamRunManifest, tasks: TeamTaskState[]): void {
 	atomicWriteJsonCoalesced(manifest.tasksPath, tasks);
 	invalidateRunCache(manifest.stateRoot);
 }
@@ -226,7 +227,8 @@ export async function saveRunTasksAsync(manifest: TeamRunManifest, tasks: TeamTa
  * This is acceptable because crash recovery detects and repairs
  * inconsistent state on next session start.
  */
-export async function saveManifestAndTasksAtomic(manifest: TeamRunManifest, tasks: TeamTaskState[]): Promise<void> {
+/** @internal */
+async function saveManifestAndTasksAtomic(manifest: TeamRunManifest, tasks: TeamTaskState[]): Promise<void> {
 	await withRunLock(manifest, async () => {
 		await Promise.all([
 			atomicWriteJsonAsync(path.join(manifest.stateRoot, "manifest.json"), manifest),

package/src/state/task-claims.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from "node:crypto";
+import { randomUUID, timingSafeEqual } from "node:crypto";
 import type { TeamTaskState } from "./types.ts";
 
 export interface TaskClaimState {
@@ -18,8 +18,15 @@ export function isTaskClaimExpired(claim: TaskClaimState | undefined, now = new
 	return Number.isFinite(parsed) ? parsed <= now.getTime() : true;
 }
 
+export function timingSafeTokenMatch(a: string, b: string): boolean {
+	const bufA = Buffer.from(String(a));
+	const bufB = Buffer.from(String(b));
+	if (bufA.length !== bufB.length) return false;
+	return timingSafeEqual(bufA, bufB);
+}
+
 export function canUseTaskClaim(task: Pick<TeamTaskState, "claim">, owner: string, token: string, now = new Date()): boolean {
-	return task.claim?.owner === owner && task.claim.token === token && !isTaskClaimExpired(task.claim, now);
+	return task.claim?.owner === owner && timingSafeTokenMatch(task.claim.token, token) && !isTaskClaimExpired(task.claim, now);
 }
 
 export function claimTask<T extends TeamTaskState>(task: T, owner: string, leaseMs?: number, now = new Date()): T {

package/src/tools/safe-bash.ts

@@ -39,7 +39,8 @@ const DANGEROUS_PATTERNS = [
 
 /**
  * Linear-time check if command contains a dangerous rm pattern like "rm -rf /" or "rm -rf ~"
- * Replaces O(n²) regex backtracking with O(n) string scanning
+ * Replaces O(n²) regex backtracking with O(n) string scanning.
+ * Expanded to also block: rm -rf /etc/*, rm --recursive --force /, rm -rf ~/.ssh, etc.
  */
 function matchesDangerousRm(command: string): boolean {
 	let pos = 0;
@@ -56,32 +57,75 @@ function matchesDangerousRm(command: string): boolean {
 		// Must be followed by whitespace
 		const afterRm = rmIdx + 2;
 		if (afterRm >= len || /\s/.test(command[afterRm])) {
-			// Found "rm " - now check for -rf flags followed by / or ~
+			// Found "rm " - now check for recursive/force flags
 			let p = afterRm + 1;
+			let hasR = false;
+			let hasF = false;
 			while (p < len) {
 				// Skip whitespace
 				while (p < len && /\s/.test(command[p])) p++;
 				if (p >= len) break;
-				// Check for flag
-				if (command[p] !== "-") break;
-				p++;
-				let hasR = false, hasF = false;
-				while (p < len && /[a-zA-Z]/.test(command[p])) {
-					if (command[p] === "r" || command[p] === "R") hasR = true;
-					if (command[p] === "f" || command[p] === "F") hasF = true;
+				// Check for short flags (-r, -f, -rf, -R, -F, etc.)
+				if (command[p] === "-" && p + 1 < len && /[a-zA-Z]/.test(command[p + 1]) && command[p + 1] !== "-") {
 					p++;
+					while (p < len && /[a-zA-Z]/.test(command[p])) {
+						if (command[p] === "r" || command[p] === "R") hasR = true;
+						if (command[p] === "f" || command[p] === "F") hasF = true;
+						p++;
+					}
+					// Skip whitespace after flag
+					while (p < len && /\s/.test(command[p])) p++;
+					continue;
 				}
-				if (!hasR && !hasF) break; // Flag must have r or f
-				// Skip whitespace after flag
-				while (p < len && /\s/.test(command[p])) p++;
-			}
-			// Now check if followed by / or ~ (end or whitespace)
-			if (p < len && (command[p] === "/" || command[p] === "~")) {
-				const afterSlash = p + 1;
-				if (afterSlash >= len || /\s/.test(command[afterSlash]) || command[afterSlash] === ";") {
-					return true; // Dangerous!
+				// Check for long flags (--recursive, --force)
+				if (command[p] === "-" && p + 1 < len && command[p + 1] === "-") {
+					p += 2;
+					const flagStart = p;
+					while (p < len && /[a-zA-Z]/.test(command[p])) p++;
+					const flagName = command.slice(flagStart, p);
+					if (flagName === "recursive") hasR = true;
+					if (flagName === "force") hasF = true;
+					// Skip whitespace after flag
+					while (p < len && /\s/.test(command[p])) p++;
+					continue;
 				}
+				// Not a flag — stop parsing flags
+				break;
+			}
+			// Must have both -r and -f (or equivalents) to be dangerous
+			if (!hasR || !hasF) {
+				pos = rmIdx + 1;
+				continue;
+			}
+			// Now check if followed by dangerous targets
+			if (p >= len) {
+				pos = rmIdx + 1;
+				continue;
+			}
+			// Block: ~ (home directory references)
+			const charAtP = command[p];
+			if (charAtP === "~") return true; // Home directory reference
+			// Block: / (root or dangerous system paths)
+			if (charAtP === "/") {
+				// Exact root '/' with nothing after
+				if (p + 1 >= len || /\s/.test(command[p + 1]) || command[p + 1] === ";") return true;
+				// Block dangerous system paths
+				const rest = command.slice(p);
+				if (/^\/etc[\/\s;]/.test(rest) || rest === "/etc") return true;
+				if ((/^\/var\/(?!tmp)/.test(rest)) || rest === "/var") return true;
+				if (/^\/usr[\/\s;]/.test(rest) || rest === "/usr") return true;
+				if (/^\/boot[\/\s;]/.test(rest) || rest === "/boot") return true;
+				if (/^\/sys[\/\s;]/.test(rest) || rest === "/sys") return true;
+				if (/^\/proc[\/\s;]/.test(rest) || rest === "/proc") return true;
+				if (/^\/dev[\/\s;]/.test(rest) || rest === "/dev") return true;
+				if (/^\/root[\/\s;]/.test(rest) || rest === "/root") return true;
+				if (/^\/home[\/\s;]/.test(rest) || rest === "/home") return true;
+				// /tmp/ and other non-system absolute paths are allowed
 			}
+			// Check for sensitive relative paths: .ssh, .gnupg
+			const rest = command.slice(p);
+			if (/^\.ssh[\/\\\s;]/.test(rest)) return true;
+			if (/^\.gnupg[\/\\\s;]/.test(rest)) return true;
 		}
 		pos = rmIdx + 1;
 	}
@@ -172,8 +216,13 @@ export function isDangerous(command: string, options: SafeBashOptions = {}): str
 		}
 	}
 
-	// Normalize: remove line continuations, collapse whitespace
-	const normalized = command.replace(/\\\n/g, " ").replace(/\s+/g, " ").trim();
+	// Normalize: strip ANSI escapes and control chars, remove line continuations, collapse whitespace
+	const normalized = command
+		.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')  // strip ANSI escapes
+		.replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '')  // strip control chars
+		.replace(/\\\n/g, " ")
+		.replace(/\s+/g, " ")
+		.trim();
 
 	// Check allow patterns first (overrides)
 	for (const pattern of allowPatterns) {

package/src/types/new-api-types.ts

@@ -11,24 +11,29 @@ export type {
 // Using AgentEndEvent and AgentStartEvent instead
 
 // Type guards for pi-crew usage
-export function isToolEvent(event: AgentSessionEvent): boolean {
+/** @internal */
+function isToolEvent(event: AgentSessionEvent): boolean {
   return event.type === "tool_execution_start" || 
          event.type === "tool_execution_update" || 
          event.type === "tool_execution_end";
 }
 
-export function isAgentLifecycleEvent(event: AgentSessionEvent): boolean {
+/** @internal */
+function isAgentLifecycleEvent(event: AgentSessionEvent): boolean {
   return event.type === "agent_start" || event.type === "agent_end";
 }
 
-export function isCompactionEvent(event: AgentSessionEvent): boolean {
+/** @internal */
+function isCompactionEvent(event: AgentSessionEvent): boolean {
   return event.type === "compaction_start" || event.type === "compaction_end";
 }
 
-export function isRetryEvent(event: AgentSessionEvent): boolean {
+/** @internal */
+function isRetryEvent(event: AgentSessionEvent): boolean {
   return event.type === "auto_retry_start" || event.type === "auto_retry_end";
 }
 
-export function isQueueEvent(event: AgentSessionEvent): boolean {
+/** @internal */
+function isQueueEvent(event: AgentSessionEvent): boolean {
   return event.type === "queue_update";
 }

package/src/ui/keybinding-map.ts

@@ -21,7 +21,8 @@ export const DASHBOARD_KEYS = {
 	notification: { dismissAll: ["H"] },
 } as const;
 
-export const KEY_RESERVED = new Set<string>([
+/** @internal */
+const KEY_RESERVED = new Set<string>([
 	...DASHBOARD_KEYS.close,
 	...DASHBOARD_KEYS.select,
 	...Object.values(DASHBOARD_KEYS.root).flat(),

package/src/ui/run-action-dispatcher.ts

@@ -111,7 +111,8 @@ export async function dispatchDiagnosticExport(ctx: ExtensionContext, runId: str
 	}
 }
 
-export function defaultNudgeAgentId(ctx: Pick<ExtensionContext, "cwd">, runId: string): string | undefined {
+/** @internal */
+function defaultNudgeAgentId(ctx: Pick<ExtensionContext, "cwd">, runId: string): string | undefined {
 	const loaded = loadRunManifestById(ctx.cwd, runId);
 	if (!loaded) return undefined;
 	return readCrewAgents(loaded.manifest).find((agent) => agent.status === "running" || agent.status === "queued")?.taskId;

package/src/ui/status-colors.ts

@@ -47,7 +47,8 @@ export function iconForStatus(status: RunStatus, options?: { runningGlyph?: stri
 	}
 }
 
-export function colorForActivity(activityState: string | undefined): CrewThemeColor {
+/** @internal */
+function colorForActivity(activityState: string | undefined): CrewThemeColor {
 	if (activityState === "needs_attention") return "warning";
 	if (activityState === "stale") return "error";
 	return "dim";

package/src/ui/syntax-highlight.ts

@@ -22,7 +22,8 @@ function buildCliTheme(theme: CrewTheme): Record<string, (text: string) => strin
 	};
 }
 
-export function detectLanguageFromPath(filePath: string): string | undefined {
+/** @internal */
+function detectLanguageFromPath(filePath: string): string | undefined {
 	const ext = filePath.split(".").pop()?.toLowerCase();
 	if (!ext) return undefined;
 	return languageMap[ext];