pi-crew 0.9.12 → 0.9.13

package/src/runtime/handoff-manager.ts

@@ -99,6 +99,9 @@ export interface HandoffSummary {
 
 	// Context snapshot
 	contextSnapshot: string;
+
+	/** Worker output text propagated through the chain (read from resultArtifact). */
+	outputText?: string;
 }
 
 /**
@@ -121,6 +124,9 @@ export interface TaskResult {
 	filesDeleted?: string[];
 	decisions?: Decision[];
 	error?: string;
+
+	/** Worker's textual output (read from resultArtifact during chain execution). */
+	outputText?: string;
 }
 
 /**
@@ -443,6 +449,7 @@ export class HandoffManager {
 			},
 
 			contextSnapshot,
+			...(result.outputText ? { outputText: result.outputText } : {}),
 		};
 	}
 

package/src/runtime/live-session-runtime.ts

@@ -4,8 +4,13 @@ import type { AgentConfig } from "../agents/agent-config.ts";
 import type { CrewRuntimeConfig } from "../config/config.ts";
 import type { TeamRunManifest, TeamTaskState, UsageState } from "../state/types.ts";
 import { appendEvent } from "../state/event-log.ts";
-import { buildMemoryBlock } from "./agent-memory.ts";
 import { trackTaskUsage } from "./usage-tracker.ts";
+// NOTE: buildMemoryBlock is intentionally NOT imported here. The agent memory
+// block is injected via renderTaskPrompt().full (the USER prompt), which is
+// shared by both the child-pi path (no system prompt) and the live-session
+// path. Adding it to liveSystemPrompt() too duplicated the entire memory
+// block (up to 200 lines) in both the user and system prompts. Keep memory
+// in a single place: the shared user prompt. See G3 fix.
 import { createStreamingOutput, type StreamingOutputHandle } from "./streaming-output.ts";
 import { registerLiveAgent, disposeLiveAgentSession, terminateLiveAgent, updateLiveAgentStatus, trackLiveAgentToolStart, trackLiveAgentToolEnd, trackLiveAgentTurnEnd, trackLiveAgentResponseText, markLiveAgentCompleted } from "./live-agent-manager.ts";
 import { applyLiveAgentControlRequest, applyLiveAgentControlRequests, type LiveAgentControlCursor } from "./live-agent-control.ts";
@@ -371,8 +376,10 @@ function compressSessionToolDescriptions(session: LiveSessionLike): void {
 	// is loaded and tree-shakeable, so adding the actual logic later is trivial.
 }
 
-function liveSystemPrompt(input: LiveSessionSpawnInput): string {
-	const memory = input.agent.memory ? buildMemoryBlock(input.agent.name, input.agent.memory, input.task.cwd, Boolean(input.agent.tools?.some((tool) => tool === "write" || tool === "edit"))) : "";
+export function liveSystemPrompt(input: LiveSessionSpawnInput): string {
+	// Agent MEMORY is intentionally omitted here — it is already injected via
+	// renderTaskPrompt().full (the user prompt, shared with the child-pi path).
+	// See the import-block note above and the G3 fix.
 	const role = input.task.role;
 	const styleBlock = buildCommunicationStyle(role);
 	const contractBlock = buildOutputContract(role);
@@ -390,7 +397,6 @@ function liveSystemPrompt(input: LiveSessionSpawnInput): string {
 		sensitiveConstraint,
 		"",
 		input.agent.systemPrompt || "Follow the user task exactly and report verification evidence.",
-		memory ? `\n${memory}` : "",
 	].filter(Boolean).join("\n");
 }
 

package/src/runtime/pi-json-output.ts

@@ -75,7 +75,11 @@ function textFromContent(content: unknown): string[] {
 	return text;
 }
 
-function extractText(value: unknown): string[] {
+/** Extract assistant-text fragments from a parsed Pi JSON event.
+ *  Exported so {@link ChildPiLineObserver} can capture the RAW (uncapped)
+ *  assistant text for the authoritative result, mirroring the extraction
+ *  order this function uses inside {@link parsePiJsonOutput}. */
+export function extractText(value: unknown): string[] {
 	const obj = asRecord(value);
 	if (!obj) return [];
 	const message = asRecord(obj.message);

package/src/runtime/task-output-context.ts

@@ -14,6 +14,12 @@ export interface DependencyContextEntry {
 	status: string;
 	resultSummary: string;
 	resultPath?: string;
+	/** Absolute path to the FULL (untruncated) result, teed when the inline
+	 *  resultSummary was materially truncated (>TEE_THRESHOLD_MULTIPLIER). The
+	 *  downstream worker can `read` this to recover the dropped middle. Mirrors
+	 *  the sharedReads recovery path so dependency injection is no longer
+	 *  circular (re-reading resultPath used to yield the same truncated text). */
+	fullOutputPath?: string;
 	structuredResults?: Record<string, unknown>;
 	artifactsProduced?: string[];
 	usage?: { inputTokens: number; outputTokens: number; durationMs: number };
@@ -50,6 +56,16 @@ function containedExists(filePath: string, baseDir?: string): boolean {
  */
 export const MAX_RESULT_INLINE_BYTES = 32_000;
 
+/**
+ * Tee-recovery multiplier (R2). A shared artifact is teed to disk — so the
+ * downstream worker can `read` the dropped middle — when its size exceeds
+ * this fraction of {@link MAX_RESULT_INLINE_BYTES}. Lowered from 2.0
+ * (64 KB) to 1.25 (40 KB) so the 32–64 KB band, where the head+tail split
+ * is already materially lossy for structured content, also gets a recovery
+ * path instead of losing the middle forever.
+ */
+export const TEE_THRESHOLD_MULTIPLIER = 1.25;
+
 /**
  * Read a file and return its content, truncating to a head+tail slice if it
  * exceeds {@link MAX_RESULT_INLINE_BYTES} characters. Multi-byte UTF-8
@@ -110,10 +126,11 @@ function writeTeeFile(fullOutputPath: string, content: string): boolean {
  * content AND (when tee was actually written) the absolute path to the full
  * file. Returns undefined if the file cannot be read at all.
  *
- * Tee threshold: only when content.length > 2 * MAX_RESULT_INLINE_BYTES
- * (the head+tail is materially lossy — small over-threshold files are not
- * teed because the inline content is mostly intact and the worker can live
- * with the 75/25 split). File content is read once and reused for both the
+ * Tee threshold: only when content.length > TEE_THRESHOLD_MULTIPLIER ×
+ * MAX_RESULT_INLINE_BYTES (R2: 1.25× = 40 KB; previously 2× = 64 KB). Below
+ * the tee threshold the head+tail split is mostly intact and the worker can
+ * live with it; at/above the threshold the dropped middle is recoverable via
+ * the teed full file. File content is read once and reused for both the
  * pipeline (truncation) and the tee write (full file).
  *
  * Truncation behavior is unchanged from the P0-A pipeline: ANSI strip +
@@ -131,8 +148,10 @@ export function readIfSmallWithTee(
 		const content = fs.readFileSync(safePath, "utf-8");
 		if (content.length > maxChars) {
 			let fullOutputPath: string | undefined;
-			// Tee only when truncation is materially lossy (>2× threshold).
-			if (opts.tee && content.length > maxChars * 2) {
+			// Tee when truncation is materially lossy (>TEE_THRESHOLD_MULTIPLIER ×
+			// threshold). R2: lowered from 2× (64 KB) to 1.25× (40 KB) so the
+			// 32–64 KB band also gets a recovery path.
+			if (opts.tee && content.length > maxChars * TEE_THRESHOLD_MULTIPLIER) {
 				if (writeTeeFile(opts.tee.fullOutputPath, content)) {
 					fullOutputPath = opts.tee.fullOutputPath;
 				}
@@ -267,13 +286,18 @@ export function collectDependencyOutputContext(manifest: TeamRunManifest, tasks:
 	const byStep = new Map(tasks.map((item) => [item.stepId, item]).filter((entry): entry is [string, TeamTaskState] => Boolean(entry[0])));
 	const byId = new Map(tasks.map((item) => [item.id, item]));
 	const dependencies = task.dependsOn.map((dep) => byStep.get(dep) ?? byId.get(dep)).filter((item): item is TeamTaskState => Boolean(item)).map((item) => {
-		const resultText = item.resultArtifact ? readIfSmall(item.resultArtifact.path, manifest.artifactsRoot) : undefined;
+		const fullOutputPath = item.resultArtifact ? teePathForArtifact(manifest.artifactsRoot, task.id, item.id) : undefined;
+		const teeResult = item.resultArtifact
+			? readIfSmallWithTee(item.resultArtifact.path, { baseDir: manifest.artifactsRoot, ...(fullOutputPath ? { tee: { fullOutputPath } } : {}) })
+			: undefined;
+		const resultText = teeResult?.content;
 		return {
 			taskId: item.id,
 			role: item.role,
 			status: item.status,
 			resultSummary: resultText ?? "",
 			resultPath: item.resultArtifact?.path,
+			...(teeResult?.fullOutputPath ? { fullOutputPath: teeResult.fullOutputPath } : {}),
 			structuredResults: resultText ? tryParseJson(resultText) : undefined,
 			artifactsProduced: listTaskArtifacts(manifest, item.id),
 			usage: aggregateUsage(item),
@@ -317,6 +341,11 @@ export function renderDependencyOutputContext(context: DependencyOutputContext):
 		parts.push("# Dependency Outputs", "");
 		for (const dep of context.dependencies) {
 			parts.push(`## ${dep.taskId} (${dep.role})`, `Status: ${dep.status}`, dep.resultPath ? `Result artifact: ${dep.resultPath}` : "", "", dep.resultSummary?.trim() || "(no result output)", "");
+			// P1-A dependency tee-recovery hint: when the dependency's result was
+			// materially truncated (>1.25× MAX_RESULT_INLINE_BYTES) the full RAW
+			// content was teed to fullOutputPath. Mirrors the sharedReads hint so the
+			// downstream worker can read the dropped middle instead of re-deriving.
+			if (dep.fullOutputPath) parts.push(`Full output (if you need the missing middle): ${dep.fullOutputPath}`, "");
 			if (dep.structuredResults) parts.push("Structured results:", JSON.stringify(dep.structuredResults, null, 2), "");
 			if (dep.artifactsProduced?.length) parts.push(`Artifacts produced: ${dep.artifactsProduced.join(", ")}`, "");
 			if (dep.usage) parts.push(`Usage: ${dep.usage.inputTokens} input tokens, ${dep.usage.outputTokens} output tokens, ${dep.usage.durationMs}ms`, "");

package/src/runtime/task-runner/prompt-builder.ts

@@ -120,7 +120,11 @@ export async function renderTaskPrompt(manifest: TeamRunManifest, step: Workflow
 		// O4: project knowledge (.crew/knowledge.md) — workers don't load the
 		// pi-crew extension (spawned with --no-extensions), so before_agent_start
 		// never fires for them. Inject here so every worker sees project knowledge.
-		buildKnowledgeFragment(task.cwd),
+		buildKnowledgeFragment(task.cwd, {
+			goal: manifest.goal,
+			taskText: step.task,
+			role: step.role,
+		}),
 	].filter(Boolean).join("\n");
 
 	// Dynamic suffix: goal, step, skills, task packet, dependency context, memory — changes per task

package/src/runtime/task-runner.ts

@@ -342,6 +342,7 @@ export async function runTeamTask(
 		let error: string | undefined;
 		let modelAttempts: ModelAttemptSummary[] | undefined;
 		let parsedOutput: ParsedPiJsonOutput | undefined;
+	let rawFinalText: string | undefined;
 		let finalStdout = "";
 		let transcriptPath: string | undefined;
 		let terminalEvidence: OperationTerminalEvidence[] = [];
@@ -717,6 +718,7 @@ export async function runTeamTask(
 					childResult.stdout,
 				);
 				parsedOutput = parsePiJsonOutput(transcriptText);
+				rawFinalText = childResult.rawFinalText;
 				error =
 					childResult.error ||
 					(childResult.exitCode && childResult.exitCode !== 0
@@ -836,6 +838,11 @@ export async function runTeamTask(
 				kind: "result",
 				relativePath: `results/${task.id}.txt`,
 				content:
+					// Prefer the RAW (uncapped) final assistant text captured before the
+					// transcript's 16K compaction — this is the authoritative worker output.
+					// Fall back to transcript-derived finalText, then stdout/stderr, so a
+					// missing raw capture (mock/error path) never yields empty/garbage.
+					cleanResultText(rawFinalText) ??
 					cleanResultText(parsedOutput?.finalText) ??
 					cleanResultText(finalStdout) ??
 					cleanResultText(finalStderr) ??

package/src/schema/team-tool-schema.ts

@@ -114,6 +114,12 @@ export const TeamToolParams = Type.Object({
 	goal: Type.Optional(
 		Type.String({ description: "High-level objective for a team run." }),
 	),
+	chain: Type.Optional(
+		Type.String({
+			description:
+				'Chain expression: "step1 -> step2 -> step3". Runs each step as a sequential team run, passing handoff context forward via the goal text. Supports inline goals ("...") and @team references. e.g. chain=\'"Research X" -> "Analyze" -> "Write report"\'.',
+		}),
+	),
 	task: Type.Optional(
 		Type.String({
 			description: "Concrete task text for direct role/agent execution.",
@@ -370,6 +376,9 @@ export interface TeamToolParamsValue {
 	role?: string;
 	agent?: string;
 	goal?: string;
+	/** Chain expression: "step1 -> step2 -> step3". Runs each step as a sequential
+	 *  team run with handoff context passed forward via the goal. */
+	chain?: string;
 	task?: string;
 	singleAgent?: boolean;
 	runId?: string;