@pmelab/gtd 36.0.0 → 38.0.0

package/dist/chunks/{wire-D3Rc5r22.mjs → wire-CSsa3Wxd.mjs}

@@ -116,6 +116,7 @@ const statusOf = (input) => {
 		initial,
 		model: rendered.model,
 		system: rendered.system !== void 0 && rendered.system !== "" ? rendered.system : void 0,
+		context: rendered.context,
 		log,
 		state: rendered.state,
 		actor: rendered.actor,
@@ -169,7 +170,7 @@ const dispatchFieldsOf = (demand) => {
 	}
 };
 /**
-* Flatten a `Demand` plus its `BeatStatus` into the single 25-key document
+* Flatten a `Demand` plus its `BeatStatus` into the single 26-key document
 * `gtd next --json` emits — the ONLY place the two are joined. `cost`/
 * `costByModel` are omitted together, exactly when no cost was recorded
 * (`cost <= 0`).
@@ -186,6 +187,7 @@ const beatDocument = (demand, status) => {
 		session,
 		model: status.model,
 		system: status.system,
+		context: status.context,
 		validate,
 		log: status.log,
 		state: status.state,
@@ -488,4 +490,117 @@ const slicesDocument = (slices) => ({
 });
 const renderSlicesJson = (document) => JSON.stringify(document) + "\n";
 //#endregion
-export { WIRE_SCHEMA as A, EXIT_RUNTIME_ERROR as C, EXIT_USAGE_ERROR as D, EXIT_STRAYS_FOUND as E, ACCESS_REFUSAL as O, EXIT_OK as S, EXIT_SIGTERM as T, BEAT_KINDS as _, selectPath as a, stallDiagnosis as b, landProseText as c, renderLandPlain as d, DEMAND_BRIEFING as f, statusOf as g, renderBeatJson as h, resolveSession as i, renderFormat as j, UNATTRIBUTED_MODEL as k, noopText as l, beatDocument as m, slicesDocument as n, judgeJson as o, renderBeatPlain as p, globMatches as r, landFields as s, renderSlicesJson as t, renderLandJson as u, beatKindOf as v, EXIT_SIGINT as w, EXIT_CODES as x, demandOf as y };
+//#region src/wire/ContextLimit.ts
+const DEFAULT_CONTEXT_LIMIT = {
+	soft: .6,
+	hard: .7
+};
+const DEFAULT_WINDOW = 2e5;
+const LONG_WINDOW = 1e6;
+/** Claude Code's `[1m]` suffix selects the long window; a transcript never names it, so the driver decides from the model it passed. */
+const contextWindowFor = (model) => model !== void 0 && /\[1m\]/i.test(model) ? LONG_WINDOW : DEFAULT_WINDOW;
+/** A positive whole number of tokens, or `undefined` for anything else. */
+const parseContextWindow = (raw) => {
+	const n = Number(raw);
+	return raw !== void 0 && raw.trim() !== "" && Number.isInteger(n) && n > 0 ? n : void 0;
+};
+/**
+* Where a driver asks `gtd context-hook` to record a hard stop's `stopReason`:
+* Claude Code prints it nowhere a driver reads, and `hook_stopped` alone would
+* also name any other hook that stopped the turn.
+*/
+const CONTEXT_STOP_FILE_ENV = "GTD_LOOP_CONTEXT_STOP_FILE";
+/**
+* Why one layer of a limit (a scope's, a step's) is malformed, ignoring how its
+* two shares relate: layers merge key by key, so only the merged limit has to
+* keep `soft` below `hard`. Config is evaluated untyped, so anything may arrive.
+*/
+const contextShapeFault = (limit) => {
+	if (typeof limit !== "object" || limit === null || Array.isArray(limit)) return `context must be an object { soft, hard }, got ${JSON.stringify(limit)}`;
+	const unknown = Object.keys(limit).filter((key) => key !== "soft" && key !== "hard");
+	if (unknown.length > 0) return `unknown key(s) ${unknown.join(", ")} in context`;
+	const shares = limit;
+	for (const key of ["soft", "hard"]) {
+		const value = shares[key];
+		if (value === void 0) continue;
+		if (typeof value !== "number" || !(value > 0 && value <= 1)) return `context.${key} must be a share of the context window in (0, 1], got ${JSON.stringify(value)}`;
+	}
+};
+/** Why a whole limit is unusable, or `undefined` when it is fine. */
+const contextLimitFault = (limit) => {
+	const shape = contextShapeFault(limit);
+	if (shape !== void 0) return shape;
+	const shares = limit;
+	const soft = shares.soft ?? DEFAULT_CONTEXT_LIMIT.soft;
+	const hard = shares.hard ?? DEFAULT_CONTEXT_LIMIT.hard;
+	return soft < hard ? void 0 : `context.soft (${soft}) must be below context.hard (${hard})`;
+};
+const record = (value) => typeof value === "object" && value !== null ? value : void 0;
+const count = (value) => typeof value === "number" && value > 0 ? value : 0;
+/** What a message's usage puts in the context window: its whole input, cached or not. */
+const usageTokens = (usage) => {
+	const u = record(usage);
+	if (u === void 0) return void 0;
+	return count(u["input_tokens"]) + count(u["cache_read_input_tokens"]) + count(u["cache_creation_input_tokens"]);
+};
+/**
+* The context size of the latest assistant message in a Claude Code transcript
+* (one JSON entry per line). Usage is per message, not a running sum, so the
+* last entry alone is the window's fill.
+*/
+const transcriptTokens = (transcript) => {
+	const lines = transcript.split("\n");
+	for (let i = lines.length - 1; i >= 0; i--) {
+		const line = lines[i].trim();
+		if (line === "") continue;
+		let entry;
+		try {
+			entry = JSON.parse(line);
+		} catch {
+			continue;
+		}
+		if (record(entry)?.["type"] !== "assistant") continue;
+		const tokens = usageTokens(record(record(entry)?.["message"])?.["usage"]);
+		if (tokens !== void 0) return tokens;
+	}
+};
+/**
+* A worker subagent's own transcript. A hook its tool call fires is handed the
+* MAIN session's `transcript_path`; the worker's sits beside it.
+*/
+const subagentTranscriptPath = (transcriptPath, agentId) => `${transcriptPath.replace(/\.jsonl$/, "")}/subagents/agent-${agentId}.jsonl`;
+/** Every hard stop's `stopReason` starts with this: the driver's context-limit marker. */
+const CONTEXT_LIMIT_MARKER = "gtd: context limit";
+const percent = (share) => `${Math.round(share * 100)}%`;
+/**
+* What a hook answers, or `undefined` to let the run go on. Compaction about
+* to happen means the limit was missed, so `PreCompact` is a hard stop whatever
+* the count says.
+*/
+const contextHook = (input) => {
+	const { event, tokens, window, limit } = input;
+	if (event === "PreCompact") return {
+		kind: "hard",
+		stopReason: `${CONTEXT_LIMIT_MARKER}: the context is about to be compacted — the run is too big for one turn`
+	};
+	if (tokens === void 0) return void 0;
+	const used = `${tokens} of ${window} tokens`;
+	if (tokens >= limit.hard * window) return {
+		kind: "hard",
+		stopReason: `${CONTEXT_LIMIT_MARKER}: ${used}, past the ${percent(limit.hard)} hard limit`
+	};
+	if (tokens >= limit.soft * window) return {
+		kind: "soft",
+		reason: `Context limit: ${used} used, past the ${percent(limit.soft)} soft limit. Stop working now. Do not start anything new; end your turn with a short handoff note as your answer: what you touched, and what was next.`
+	};
+};
+/** A decision as Claude Code's settings-hook JSON output. */
+const hookOutput = (decision) => decision.kind === "soft" ? {
+	decision: "block",
+	reason: decision.reason
+} : {
+	continue: false,
+	stopReason: decision.stopReason
+};
+//#endregion
+export { beatKindOf as A, ACCESS_REFUSAL as B, renderLandPlain as C, renderBeatJson as D, beatDocument as E, EXIT_RUNTIME_ERROR as F, WIRE_SCHEMA as H, EXIT_SIGINT as I, EXIT_SIGTERM as L, stallDiagnosis as M, EXIT_CODES as N, statusOf as O, EXIT_OK as P, EXIT_STRAYS_FOUND as R, renderLandJson as S, renderBeatPlain as T, renderFormat as U, UNATTRIBUTED_MODEL as V, selectPath as _, contextLimitFault as a, landProseText as b, hookOutput as c, transcriptTokens as d, usageTokens as f, resolveSession as g, globMatches as h, contextHook as i, demandOf as j, BEAT_KINDS as k, parseContextWindow as l, slicesDocument as m, CONTEXT_STOP_FILE_ENV as n, contextShapeFault as o, renderSlicesJson as p, DEFAULT_CONTEXT_LIMIT as r, contextWindowFor as s, CONTEXT_LIMIT_MARKER as t, subagentTranscriptPath as u, judgeJson as v, DEMAND_BRIEFING as w, noopText as x, landFields as y, EXIT_USAGE_ERROR as z };