@themoltnet/pi-extension 0.8.0 → 0.9.0

package/dist/index.d.ts

@@ -281,6 +281,8 @@ declare const Task: TObject<    {
     cancelledByHumanId: TUnion<[TString, TNull]>;
     cancelReason: TUnion<[TString, TNull]>;
     maxAttempts: TNumber;
+    dispatchTimeoutSec: TUnion<[TInteger, TNull]>;
+    runningTimeoutSec: TUnion<[TInteger, TNull]>;
 }>;
 
 declare type Task = Static<typeof Task>;
@@ -364,6 +366,26 @@ declare interface TaskReporter {
     finalize(usage: TaskUsage): Promise<void>;
     /** Flush buffers + release resources. Called once. Idempotent. */
     close(): Promise<void>;
+    /**
+     * Signal that aborts when the task is cancelled by the imposer (or a
+     * diary writer) while the executor is running. `ApiTaskReporter`
+     * aborts this on the next heartbeat that observes `cancelled: true`
+     * in the response (#938). Local reporters (`StdoutReporter`,
+     * `JsonlTaskReporter`) never abort — there's no remote cancel
+     * channel for `FileTaskSource`.
+     *
+     * Executors should pass this signal into long-running work
+     * (LLM calls, sandbox execution, file ops) and surface a
+     * `status: 'cancelled'` output when it fires. The runtime also
+     * checks the signal post-execute and converts any output to
+     * `cancelled` if the executor returned without honoring it.
+     */
+    readonly cancelSignal: AbortSignal;
+    /**
+     * The reason supplied to `/tasks/:id/cancel` by the canceller, if
+     * cancellation has been observed. Null until `cancelSignal` aborts.
+     */
+    readonly cancelReason: string | null;
 }
 
 /**

package/dist/index.js

@@ -9338,7 +9338,15 @@ Type$1.Object({
 	cancelledByAgentId: Type$1.Union([Uuid, Type$1.Null()]),
 	cancelledByHumanId: Type$1.Union([Uuid, Type$1.Null()]),
 	cancelReason: Type$1.Union([Type$1.String(), Type$1.Null()]),
-	maxAttempts: Type$1.Number({ minimum: 1 })
+	maxAttempts: Type$1.Number({ minimum: 1 }),
+	dispatchTimeoutSec: Type$1.Union([Type$1.Integer({
+		minimum: 1,
+		maximum: 86400
+	}), Type$1.Null()]),
+	runningTimeoutSec: Type$1.Union([Type$1.Integer({
+		minimum: 1,
+		maximum: 86400
+	}), Type$1.Null()])
 }, {
 	$id: "Task",
 	additionalProperties: false
@@ -9499,11 +9507,7 @@ function buildAssessBriefPrompt(input, ctx) {
 */
 function buildCuratePackPrompt(input, ctx) {
 	const { diaryId, taskPrompt, entryTypes, tagFilters, tokenBudget, recipe } = input;
-	const effectiveEntryTypes = entryTypes ?? [
-		"semantic",
-		"episodic",
-		"procedural"
-	];
+	const entryTypesPinned = Boolean(entryTypes);
 	const resolvedRecipe = recipe ?? "topic-focused-v1";
 	const includeLine = tagFilters?.include?.length ? `- Hard include (ALL must be present on an entry): ${tagFilters.include.map((t) => `\`${t}\``).join(", ")}` : null;
 	const excludeLine = tagFilters?.exclude?.length ? `- Hard exclude (drop if ANY present): ${tagFilters.exclude.map((t) => `\`${t}\``).join(", ")}` : null;
@@ -9532,7 +9536,16 @@ function buildCuratePackPrompt(input, ctx) {
 		"",
 		"## Constraints",
 		"",
-		`- Entry types in play: ${effectiveEntryTypes.map((t) => `\`${t}\``).join(", ")}`,
+		entryTypesPinned ? `- Entry types pinned by imposer (do not widen): ${entryTypes.map((t) => `\`${t}\``).join(", ")}` : "- Entry types: **you choose**. The diary contains three kinds:",
+		entryTypesPinned ? null : "  - `episodic` — incident reports, \"what happened and how we fixed it\" narratives.",
+		entryTypesPinned ? null : "  - `semantic` — durable decisions, patterns, design rationale.",
+		entryTypesPinned ? null : "  - `procedural` — commit audit trails / changelog-style provenance.",
+		entryTypesPinned ? null : "  Pick the subset that fits the prompt. For \"failures and workarounds\"",
+		entryTypesPinned ? null : "  or \"decisions we made\" you generally do NOT want `procedural` — those",
+		entryTypesPinned ? null : "  entries are append-only commit logs and produce changelog-shaped packs.",
+		entryTypesPinned ? null : "  Include `procedural` only when the prompt explicitly asks for changelog-",
+		entryTypesPinned ? null : "  style content (e.g., \"what shipped this week\"). State your choice",
+		entryTypesPinned ? null : "  briefly in the final `summary`.",
 		`- Recipe tag: \`${resolvedRecipe}\` (recorded on pack params)`,
 		tokenBudget ? `- Token budget (soft cap on final pack): ${tokenBudget}. Pick entry count so the pack fits — estimate ~300 tok/entry as a starting heuristic, tighten after inspecting actual content lengths.` : "- No token budget — size the pack to match the prompt, not an arbitrary target.",
 		includeLine,
@@ -10037,6 +10050,20 @@ async function executePiTask(claimedTask, reporter, opts) {
 	const attemptN = claimedTask.attemptN;
 	const startTime = Date.now();
 	const mountPath = opts.mountPath ?? process.cwd();
+	if (reporter.cancelSignal.aborted) return {
+		taskId: task.id,
+		attemptN,
+		status: "cancelled",
+		output: null,
+		outputCid: null,
+		usage: emptyUsage(opts.provider, opts.model),
+		durationMs: Date.now() - startTime,
+		error: {
+			code: "task_cancelled",
+			message: reporter.cancelReason ?? "Task cancelled before pi executor started.",
+			retryable: false
+		}
+	};
 	const checkpointPath = opts.checkpointPath ?? await ensureSnapshot({
 		config: opts.sandboxConfig?.snapshot,
 		onProgress: opts.onSnapshotProgress ?? ((m) => {
@@ -10065,6 +10092,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 	let reporterOpen = false;
 	let session = null;
 	const finalUsage = emptyUsage(opts.provider, opts.model);
+	let cancelListener = null;
 	const makeFailedOutput = (code, message, usage = finalUsage) => ({
 		taskId: task.id,
 		attemptN,
@@ -10165,6 +10193,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 		let assistantText = "";
 		let reporterError = null;
 		const usage = finalUsage;
+		cancelListener = wireSessionAbort(reporter.cancelSignal, session);
 		const recordingPromise = [];
 		const track = (p) => {
 			recordingPromise.push(p.catch((err) => {
@@ -10220,10 +10249,11 @@ async function executePiTask(claimedTask, reporter, opts) {
 			});
 		}
 		await Promise.all(recordingPromise);
+		const cancelled = reporter.cancelSignal.aborted;
 		let parsedOutput = null;
 		let parsedOutputCid = null;
 		let parseError = null;
-		if (!runError && !llmAbort) {
+		if (!runError && !llmAbort && !cancelled) {
 			const parsed = await parseStructuredTaskOutput(assistantText, task.taskType);
 			parsedOutput = parsed.output;
 			parsedOutputCid = parsed.outputCid;
@@ -10233,6 +10263,20 @@ async function executePiTask(claimedTask, reporter, opts) {
 				phase: "output_validation"
 			});
 		}
+		if (cancelled) return {
+			taskId: task.id,
+			attemptN,
+			status: "cancelled",
+			output: null,
+			outputCid: null,
+			usage,
+			durationMs: Date.now() - startTime,
+			error: {
+				code: "task_cancelled",
+				message: reporter.cancelReason ?? "Task cancelled by imposer while pi session was running.",
+				retryable: false
+			}
+		};
 		const status = runError || llmAbort || parseError || reporterError ? "failed" : "completed";
 		const errorCode = runError?.code ?? parseError?.code ?? reporterError?.code ?? (llmAbort ? "llm_api_error" : void 0);
 		const errorMessage = runError?.message ?? parseError?.message ?? reporterError?.message ?? (llmAbort ? "LLM API error during turn" : void 0);
@@ -10253,6 +10297,7 @@ async function executePiTask(claimedTask, reporter, opts) {
 	} catch (err) {
 		return makeFailedOutput("executor_unexpected_error", err instanceof Error ? err.message : String(err));
 	} finally {
+		if (cancelListener) reporter.cancelSignal.removeEventListener("abort", cancelListener);
 		if (session) try {
 			session.dispose();
 		} catch {}
@@ -10282,6 +10327,32 @@ function emptyUsage(provider, model) {
 	};
 }
 /**
+* Wire `cancelSignal` → `session.abort()`. Returns the listener so the
+* caller can remove it on cleanup. If the signal is already aborted at
+* call time (cancel landed between session creation and wiring), fires
+* abort synchronously instead of waiting for an `'abort'` event that
+* already happened.
+*
+* Exported for unit testing without a booted Gondolin VM. The double-
+* invocation guard handles both the rare "fire from constructor + later
+* event" race and the (in-practice idempotent) double-call into
+* `session.abort()`.
+*/
+function wireSessionAbort(cancelSignal, session) {
+	let abortInvoked = false;
+	const listener = () => {
+		if (abortInvoked) return;
+		abortInvoked = true;
+		session.abort().catch((err) => {
+			const message = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`[pi] session.abort() failed: ${message}\n`);
+		});
+	};
+	if (cancelSignal.aborted) listener();
+	else cancelSignal.addEventListener("abort", listener, { once: true });
+	return listener;
+}
+/**
 * Cap oversized tool-result payloads before embedding them in a
 * `task_messages.payload` row. Bodies above 4 KiB are replaced with a
 * `{ truncated, original_size }` marker so the JSONL/DB size stays bounded.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@themoltnet/pi-extension",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "type": "module",
   "description": "MoltNet pi extension — sandboxed tool execution in Gondolin VMs with MoltNet identity and persistent memory",
   "license": "MIT",
@@ -31,7 +31,7 @@
     "@earendil-works/gondolin": "^0.7.0",
     "@opentelemetry/api": "^1.9.0",
     "@sinclair/typebox": "^0.34.0",
-    "@themoltnet/agent-runtime": "0.4.0",
+    "@themoltnet/agent-runtime": "0.5.0",
     "@themoltnet/sdk": "0.96.0"
   },
   "peerDependencies": {