dorfl 0.11.2 → 0.12.0

package/src/tasker-review-loop.ts

@@ -1,4 +1,4 @@
-import {readFileSync, readdirSync, writeFileSync} from 'node:fs';
+import {readFileSync, readdirSync, writeFileSync, rmSync} from 'node:fs';
 import {join} from 'node:path';
 import {
 	workFolderPrefix,
@@ -12,6 +12,7 @@ import {launchWithOptionalWatch} from './agent-launch.js';
 import {
 	parseReviewVerdict,
 	ReviewParseError,
+	ReviewOutputCappedError,
 	reviewDisciplinePrompt,
 	verdictContractPrompt,
 	type ReviewFinding,
@@ -26,6 +27,20 @@ import {
 // `review-protocol-doc-and-shared-machinery`).
 export type {TaskEdit, UncertainTask} from './review-verdict.js';
 export {parseReviewVerdict as parseTaskReviewVerdict} from './review-verdict.js';
+export {ReviewOutputCappedError as TaskReviewOutputCappedError} from './review-verdict.js';
+
+/**
+ * The SCRATCH directory the review agent writes full-replacement task bodies to
+ * (the DECOUPLED edits channel — see {@link TaskEdit.src}). Sibling of `backlog/`
+ * under `work/tasks/`; NOT a {@link WorkFolderKey}, so it is never scanned by
+ * {@link newOrChangedBacklog} (which reads `work/tasks/backlog/` only) and never
+ * appears as a candidate task. The runner reads each `src` file, applies it to the
+ * target `work/tasks/backlog/<name>.md` through the SAME scope fence, then DELETES
+ * it — so the integrate's `git add -A` never sweeps the scratch into the commit. A
+ * start-of-loop clean (see {@link cleanReviewEditsScratch}) reaps any stragglers a
+ * crashed prior run left behind.
+ */
+export const REVIEW_EDITS_SCRATCH_DIR = 'work/tasks/.review-edits';
 
 /**
  * **The tasker review→edit→re-review→converge LOOP** (`slicer-review-edit-loop`,
@@ -247,6 +262,10 @@ export async function runTaskReviewLoop(
 	// tasks, never pre-existing landed ones (the requeue fix). No snapshot ⇒ an
 	// empty one (the legacy whole-directory behaviour for the empty-backlog case).
 	const before = options.before ?? new Map<string, string>();
+	// Reap any review-edits SCRATCH a crashed prior run left behind, so the
+	// integrate's `git add -A` never sweeps stragglers into this run's commit. The
+	// loop deletes each `src` it applies too; this is the crash-recovery backstop.
+	cleanReviewEditsScratch(options.cwd);
 
 	let totalPasses = 0;
 	let last: SingleExecutionResult | undefined;
@@ -456,6 +475,15 @@ function applyEdits(
 			);
 			continue;
 		}
+		// Resolve the edit BODY: inline `content` (legacy / small edits) OR a `src`
+		// scratch file the agent wrote (the decoupled form — see TaskEdit.src). The
+		// `src` form keeps the verdict JSON bounded by the NUMBER of edits, not the
+		// total body size, so a large decomposition can no longer cap-truncate the
+		// verdict. A path-only edit with no resolvable body is a no-op marker.
+		const body = resolveEditBody(cwd, edit, note);
+		if (body === undefined) {
+			continue;
+		}
 		// A pre-existing task this run did NOT touch must not be overwritten: it is
 		// in `before` and the current on-disk content still equals the snapshot.
 		if (before.has(filename)) {
@@ -475,7 +503,70 @@ function applyEdits(
 			}
 		}
 		const abs = join(cwd, normalized);
-		writeFileSync(abs, edit.content);
+		writeFileSync(abs, body);
+	}
+}
+
+/**
+ * Resolve an edit's full-replacement BODY: inline `content` (legacy) takes
+ * precedence, else read the `src` scratch file the agent wrote. Returns
+ * `undefined` when there is no body to apply (neither channel present, or `src`
+ * missing / outside the scratch fence / unreadable). The `src` is fenced to
+ * {@link REVIEW_EDITS_SCRATCH_DIR} (no `..`) so the agent cannot pull an arbitrary
+ * repo file in as the edit body. A read `src` is DELETED after reading so the
+ * integrate's `git add -A` never sweeps the scratch into the commit.
+ */
+function resolveEditBody(
+	cwd: string,
+	edit: TaskEdit,
+	note: (message: string) => void,
+): string | undefined {
+	if (edit.content !== undefined) {
+		return edit.content;
+	}
+	if (edit.src === undefined) {
+		return undefined;
+	}
+	const src = edit.src.replace(/\\/g, '/');
+	if (src.includes('..') || !src.startsWith(REVIEW_EDITS_SCRATCH_DIR + '/')) {
+		note(
+			`Skipped a review edit whose src is outside ${REVIEW_EDITS_SCRATCH_DIR}/ (${edit.src}) — ` +
+				'the scratch body must live under the review-edits scratch dir.',
+		);
+		return undefined;
+	}
+	const srcAbs = join(cwd, src);
+	let body: string | undefined;
+	try {
+		body = readFileSync(srcAbs, 'utf8');
+	} catch {
+		note(
+			`Skipped a review edit whose src scratch file is missing/unreadable (${edit.src}) — ` +
+				'the agent did not write it before emitting the verdict.',
+		);
+		return undefined;
+	}
+	// Reap the scratch file now the body is in hand — never let it survive to the
+	// integrate's `git add -A` (best-effort; a missing file is already gone).
+	try {
+		rmSync(srcAbs, {force: true});
+	} catch {
+		// Best-effort: a failure to delete does not block the apply.
+	}
+	return body;
+}
+
+/**
+ * Best-effort reap of the {@link REVIEW_EDITS_SCRATCH_DIR} (a crashed prior run may
+ * have left scratch bodies behind; the integrate's `git add -A` would otherwise
+ * sweep them into the next tasking commit). Called at the START of a loop run.
+ * Never throws — a missing/unreadable dir is the normal steady state.
+ */
+function cleanReviewEditsScratch(cwd: string): void {
+	try {
+		rmSync(join(cwd, REVIEW_EDITS_SCRATCH_DIR), {recursive: true, force: true});
+	} catch {
+		// Best-effort.
 	}
 }
 
@@ -600,7 +691,28 @@ export function harnessTaskReviewGate(
 				}`,
 			);
 		}
-		return parseReviewVerdict(readOutput(launched.output));
+		// CAP-TRUNCATION NAMING (observation
+		// `tasker-review-edits-payload-caps-the-verdict-response`): attempt the parse
+		// FIRST so a verdict that DID complete (even on a capped turn — e.g. the cap
+		// hit trailing prose after the JSON closed) is HONORED, not discarded. Only
+		// when the parse FAILS AND the adapter surfaced an output-cap signal do we
+		// re-throw the NAMED {@link ReviewOutputCappedError} (a subclass of
+		// ReviewParseError, so the bounce routing still catches it — NEVER a silent
+		// approve). A parse failure with no cap signal stays the generic
+		// ReviewParseError (the adapter could not see the signal — still
+		// needs-attention, still never a silent approve).
+		try {
+			return parseReviewVerdict(readOutput(launched.output));
+		} catch (err) {
+			if (
+				launched.outputCapped !== undefined &&
+				(err instanceof ReviewParseError ||
+					err instanceof ReviewOutputCappedError)
+			) {
+				throw new ReviewOutputCappedError(launched.outputCapped);
+			}
+			throw err;
+		}
 	};
 }
 
@@ -634,16 +746,26 @@ export function buildTaskReviewPrompt(input: TaskReviewGateInput): string {
 		`loop, not a one-shot gate.`,
 		``,
 		`This is review pass ${input.pass} (fresh context ${input.execution}). You`,
-		`do NOT edit files or run git yourself — you EMIT the edits to apply as FULL`,
-		`replacement content and the runner applies them, then re-reviews. Tasks`,
+		`do NOT run git. For the EDITS, WRITE each full-replacement task body to a`,
+		`SCRATCH file under ${REVIEW_EDITS_SCRATCH_DIR}/ and reference it by path in the`,
+		`"edits" channel — do NOT inline the body in the JSON, and do NOT edit the`,
+		`candidate task files directly (the runner applies your scratch body to the`,
+		`candidate task through its scope fence + deletes the scratch; on a review`,
+		`failure the tasker's original candidates stay pristine for recovery). This`,
+		`keeps the verdict JSON bounded by the NUMBER of edits, not the total body size,`,
+		`so a large decomposition cannot cap-truncate the verdict. Tasks`,
 		`measurably keep improving when reviewed, so propose edits that fix the`,
 		`findings; converge when a pass finds NO NEW blocking issue.`,
 		``,
 		verdictContractPrompt(),
 		``,
 		`Fill the channels appropriate to THIS caller (the tasker improver loop):`,
-		`  - "edits" — full-content replacements for candidate task files when you`,
-		`    can FIX a finding by editing (the natural improver step).`,
+		`  - "edits" — for each candidate task file you want to rewrite, WRITE the full`,
+		`    replacement body to ${REVIEW_EDITS_SCRATCH_DIR}/<name>.md (the runner reads`,
+		`    it, applies it to work/tasks/backlog/<name>.md, then deletes the scratch),`,
+		`    and emit {"path": "work/tasks/backlog/<name>.md", "src": "${REVIEW_EDITS_SCRATCH_DIR}/<name>.md"}.`,
+		`    Do NOT put the body in "content" — that shares the capped response with`,
+		`    the verdict and cap-truncates it on a large set.`,
 		`  - "uncertainTasks" — specific tasks you cannot make buildable (each gets`,
 		`    \`needsAnswers: true\` with the questions in its body).`,
 		`  - "decompositionUnclear" — the WHOLE decomposition is unsound (the spec is`,

package/src/tasking.ts

@@ -44,7 +44,9 @@ import {
 	runTaskReviewLoop,
 	type TaskReviewGate,
 	type RunTaskReviewLoopResult,
+	REVIEW_EDITS_SCRATCH_DIR,
 } from './tasker-review-loop.js';
+import {ReviewParseError, ReviewOutputCappedError} from './review-verdict.js';
 import type {ReviewGate} from './review-gate.js';
 
 /**
@@ -551,22 +553,78 @@ export async function performTask(
 	//     AGENT path runs the loop — the human tasking path is unaffected.
 	let loopDisposition: RunTaskReviewLoopResult | undefined;
 	if (options.reviewLoop && doer === 'agent') {
-		loopDisposition = await runTaskReviewLoop({
-			slug,
-			cwd,
-			gate: options.reviewLoop,
-			// SCOPING FENCE (the requeue fix): the loop reviews/edits/flags ONLY the
-			// tasks THIS run produced (new-or-changed vs `before`), never the
-			// pre-existing staged tasks that share `work/tasks/backlog/`.
-			before,
-			taskerLoopMax: options.taskerLoopMax ?? 3,
-			executions: options.reviewExecutions,
-			taskerLoopModel: options.taskerLoopModel,
-			sessionsDir: options.sessionsDir,
-			// The improver loop's review AGENT launches AMBIENT, never the identity.
-			env: agentEnv,
-			note,
-		});
+		// REVIEW-LEG FAILURE handling (observation
+		// `tasker-review-edits-payload-caps-the-verdict-response`): the tasker produced
+		// a good candidate set but the review/improver leg can fail to return a
+		// parseable verdict (a generic parse failure, or the NAMED cap-truncation
+		// class). The pre-fix behaviour THREW here, crashing the run, LEAVING THE
+		// LOCK HELD, writing NO question sidecar, and DISCARDING the tasker's
+		// candidate tasks. Now: catch it, PERSIST the candidate tasks, and BOUNCE
+		// through the SAME surface the decomposition-unclear path uses (release the
+		// lock + a question sidecar). NEVER a silent approve — a parse failure is
+		// always a needs-attention route. A non-review throw (genuine wiring error)
+		// is re-thrown.
+		try {
+			loopDisposition = await runTaskReviewLoop({
+				slug,
+				cwd,
+				gate: options.reviewLoop,
+				// SCOPING FENCE (the requeue fix): the loop reviews/edits/flags ONLY the
+				// tasks THIS run produced (new-or-changed vs `before`), never the
+				// pre-existing staged tasks that share `work/tasks/backlog/`.
+				before,
+				taskerLoopMax: options.taskerLoopMax ?? 3,
+				executions: options.reviewExecutions,
+				taskerLoopModel: options.taskerLoopModel,
+				sessionsDir: options.sessionsDir,
+				// The improver loop's review AGENT launches AMBIENT, never the identity.
+				env: agentEnv,
+				note,
+			});
+		} catch (err) {
+			if (!(err instanceof ReviewParseError)) {
+				throw err;
+			}
+			const reviewErr = err as ReviewParseError;
+			// Reap any review-edits SCRATCH the failed pass left on disk so it is never
+			// swept into a later run's integrate commit.
+			try {
+				rmSync(join(cwd, REVIEW_EDITS_SCRATCH_DIR), {
+					recursive: true,
+					force: true,
+				});
+			} catch {
+				// Best-effort.
+			}
+			const candidatePaths = await persistTaskingCandidates(
+				cwd,
+				slug,
+				before,
+				arbiter,
+				env,
+				note,
+			);
+			const reason = reviewFailureReason(slug, reviewErr, candidatePaths);
+			const message = reviewFailureMessage(slug, reviewErr);
+			if (useLock) {
+				return await surfaceTaskingBlock({
+					slug,
+					cwd,
+					arbiter,
+					reason,
+					message,
+					lockedBlob,
+					release: lock.release,
+					mode: resolvedMode,
+					provider: options.providerInstance,
+					env,
+					note,
+				});
+			}
+			note(reason);
+			// Human, no-lock path: a clean park-for-human is a success terminal (exit 0).
+			return {exitCode: 0, outcome: 'needs-attention', slug, message};
+		}
 		// DECOMPOSITION UNCLEAR: emit NO guessed tasks — route the held spec to
 		// needs-attention with the questions as the reason. The lock release amends the
 		// `spec:<slug>` unified lock `active → stuck` (the tasking needs-attention surface
@@ -1332,6 +1390,130 @@ function decompositionUnclearReason(slug: string, questions: string[]): string {
 	return `${head}\n${body}`;
 }
 
+/**
+ * The needs-attention REASON for a REVIEW-LEG FAILURE (a parse failure, or the
+ * NAMED cap-truncation class — observation
+ * `tasker-review-edits-payload-caps-the-verdict-response`). The tasker produced a
+ * good candidate set but the review/improver leg could not return a parseable
+ * verdict, so the run is parked (the lock RELEASED, a question sidecar written)
+ * rather than the whole tasking discarded. Names the failure precisely so an
+ * operator does not mis-read a cap-truncation as a model flake and retry blindly.
+ * The candidate tasks the tasker produced are PERSISTED on the work branch (see
+ * {@link persistTaskingCandidates}) so a human can recover them.
+ */
+function reviewFailureReason(
+	slug: string,
+	err: ReviewParseError,
+	candidatePaths: string[],
+): string {
+	const named =
+		err instanceof ReviewOutputCappedError
+			? `The tasker review leg failed on '${slug}': ${err.message}. This is a ` +
+				"STRUCTURAL cap-truncation (the review edits payload shared the model's " +
+				'capped output response with the verdict), NOT a model flake — do not ' +
+				'blindly retry; the run is parked for you to recover the candidate tasks ' +
+				'and re-task.'
+			: `The tasker review leg failed on '${slug}': the review agent produced no ` +
+				`parseable verdict (${err.message}). The run is parked for you to recover ` +
+				'the candidate tasks and re-task.';
+	const tasks =
+		candidatePaths.length > 0
+			? `\n\nThe tasker produced ${candidatePaths.length} candidate task(s) before the ` +
+				'review leg failed; they are saved on the work branch ' +
+				`'${workBranchRef('spec', slug)}' (commit "chore(tasking): save candidate ` +
+				`tasks") for recovery:\n${candidatePaths.map((p) => `- ${p}`).join('\n')}`
+			: '\n\n(No candidate tasks were on disk when the review leg failed.)';
+	return `${named}${tasks}`;
+}
+
+/** The human-readable terminal MESSAGE for a review-leg failure (the result's `message`). */
+function reviewFailureMessage(slug: string, err: ReviewParseError): string {
+	if (err instanceof ReviewOutputCappedError) {
+		return (
+			`Tasking '${slug}' parked: the review leg hit the model output cap ` +
+			`(${err.outputTokens} tokens) and was truncated before emitting its ` +
+			'verdict. The candidate tasks were saved on the work branch; the lock was ' +
+			'released and a question surfaced.'
+		);
+	}
+	return (
+		`Tasking '${slug}' parked: the review leg produced no parseable verdict ` +
+		`(${err.message}). The candidate tasks were saved on the work branch; the ` +
+		'lock was released and a question surfaced.'
+	);
+}
+
+/**
+ * PERSIST the tasker's candidate tasks (priority: do not discard the tasker's work
+ * on the review-failure path). Commits the new-or-changed `work/tasks/backlog/*.md`
+ * (this run's own output vs `before`) to the work branch under a marker commit,
+ * then pushes the branch to the arbiter BEST-EFFORT (a push failure is noted, not
+ * fatal — the local branch commit still survives a worktree teardown and is
+ * recoverable by `git checkout work/spec-<slug>`). Returns the repo-relative
+ * candidate paths persisted (empty when there were none). Never throws — a git
+ * failure is noted and the bounce proceeds (the lock is still released).
+ */
+async function persistTaskingCandidates(
+	cwd: string,
+	slug: string,
+	before: Map<string, string>,
+	arbiter: string,
+	env: NodeJS.ProcessEnv | undefined,
+	note: (message: string) => void,
+): Promise<string[]> {
+	const candidatePaths = newOrChangedStagedTasks(cwd, before);
+	if (candidatePaths.length === 0) {
+		return [];
+	}
+	const branch = workBranchRef('spec', slug);
+	try {
+		await gitHard(['add', '--', ...candidatePaths], cwd, env);
+		// Commit only if something is actually staged (a clean tree → nothing to save).
+		const diffCached = await gitSoft(['diff', '--cached', '--quiet'], cwd, env);
+		if (diffCached.status === 0) {
+			return candidatePaths; // nothing new staged (already committed by a prior step).
+		}
+		await gitHard(
+			[
+				'commit',
+				'-q',
+				'-m',
+				`chore(tasking): save candidate tasks for '${slug}' (review leg failed; not landed)`,
+			],
+			cwd,
+			env,
+		);
+	} catch (err) {
+		note(
+			`Could not commit the candidate tasks to the work branch for recovery ` +
+				`(best-effort; the bounce still proceeds): ${
+					err instanceof Error ? err.message : String(err)
+				}`,
+		);
+		return candidatePaths;
+	}
+	// Push the work branch best-effort so the candidate tasks survive a worktree
+	// teardown on an isolated run (the branch ref survives locally too, but a push
+	// makes them remote-recoverable). A push failure is noted, never fatal.
+	try {
+		const pushed = await gitSoft(['push', arbiter, branch], cwd, env);
+		if (pushed.status !== 0) {
+			note(
+				`Could not push the candidate-tasks work branch '${branch}' to ${arbiter} ` +
+					`(best-effort; the local commit still persists for recovery).`,
+			);
+		}
+	} catch (err) {
+		note(
+			`Could not push the candidate-tasks work branch '${branch}' to ${arbiter} ` +
+				`(best-effort; the local commit still persists for recovery): ${
+					err instanceof Error ? err.message : String(err)
+				}`,
+		);
+	}
+	return candidatePaths;
+}
+
 /**
  * Mark a candidate task file `needsAnswers: true` and record its open questions in
  * its body (the loop's uncertain-task routing outcome). The runner writes the

package/src/watch-session.ts

@@ -149,6 +149,10 @@ interface SessionLogRecord {
 	message?: {
 		role?: unknown;
 		content?: unknown;
+		/** The Anthropic-API turn-termination reason (mirrored by pi into the session log). */
+		stop_reason?: unknown;
+		/** The turn's token usage (mirrored by pi). `output` OR `output_tokens` is the produced-token count. */
+		usage?: unknown;
 	};
 }
 
@@ -286,10 +290,10 @@ function assistantContentText(content: unknown): string {
 /**
  * Extract the **last assistant message's text** from a pi session `.jsonl`
  * (task `harness-agent-output`) — the agent's final ANSWER, surfaced through
- * the harness seam as `LaunchResult.output`. It REUSES this module's session-log
- * shape walk (one parser, not two): it scans the `{type:"message",
- * message:{role:"assistant", content[]}}` records, takes the LAST one carrying
- * non-empty `text`, and returns its concatenated text.
+ * the harness seam as `LaunchResult.output`. A thin delegate to
+ * {@link lastAssistantTurn} (one walk, returning the `.text`); the turn reader
+ * ALSO carries the `stop_reason`/`usage` the pi adapter uses for the
+ * `LaunchResult.outputCapped` cap-truncation signal.
  *
  * Kept as a PURE `string → string | undefined` function on purpose: the pi
  * adapter reads the session file and passes the JSONL text in, but a future
@@ -307,7 +311,33 @@ function assistantContentText(content: unknown): string {
  * line in a just-closed log must not crash the reader.
  */
 export function lastAssistantText(jsonl: string): string | undefined {
-	let last: string | undefined;
+	return lastAssistantTurn(jsonl).text;
+}
+
+/**
+ * The last assistant turn's TEXT + its Anthropic-API turn-termination signal
+ * (`stop_reason` + `usage.output`/`usage.output_tokens` token count). Reused by
+ * the pi adapter to populate BOTH `LaunchResult.output` (the `.text`) AND
+ * `LaunchResult.outputCapped` (the cap-truncation signal — see
+ * {@link isOutputCappedTurn}). One walk over the `.jsonl`, not two. `text` is the
+ * LAST assistant turn carrying non-empty text (a tool-only turn does not
+ * supersede it); `stopReason`/`outputTokens` come from THAT same last-text turn when
+ * the record carries them, else `undefined`. Returns an all-`undefined` object
+ * for an empty / assistant-text-less log.
+ */
+export interface LastAssistantTurn {
+	/** The last assistant turn's concatenated `text` parts (its answer). */
+	text?: string;
+	/** The turn's `stop_reason` (raw — `null`, `'end_turn'`, `'max_tokens'`, …). */
+	stopReason?: string | null;
+	/** The turn's produced output-token count (`usage.output` OR `usage.output_tokens`). */
+	outputTokens?: number;
+}
+
+export function lastAssistantTurn(jsonl: string): LastAssistantTurn {
+	let lastText: string | undefined;
+	let lastStopReason: string | null | undefined = undefined;
+	let lastOutputTokens: number | undefined = undefined;
 	for (const line of jsonl.split('\n')) {
 		const trimmed = line.trim();
 		if (trimmed === '') {
@@ -332,10 +362,56 @@ export function lastAssistantText(jsonl: string): string | undefined {
 		}
 		const text = assistantContentText(message.content);
 		if (text !== '') {
-			last = text; // a later text turn supersedes an earlier one.
+			lastText = text; // a later text turn supersedes an earlier one.
+			lastStopReason = readStopReason(message.stop_reason);
+			lastOutputTokens = readOutputTokens(message.usage);
 		}
 	}
-	return last;
+	return {
+		text: lastText,
+		stopReason: lastStopReason,
+		outputTokens: lastOutputTokens,
+	};
+}
+
+/**
+ * Is this assistant turn's signal an OUTPUT-CAP truncation — the turn did NOT
+ * end naturally? `stop_reason` `null`/`None`/`undefined` (the turn was cut off) OR
+ * `'max_tokens'` (the model hit its output-token cap), together with a positive
+ * produced-token count. The `null`/`None` form is what pi's session log records
+ * when the `--print` run is truncated before the turn closes (observation
+ * `tasker-review-edits-payload-caps-the-verdict-response`); `'max_tokens'` is the
+ * standard API cap signal. Both name the same structural cause: the verdict never
+ * finished.
+ */
+export function isOutputCappedTurn(turn: LastAssistantTurn): boolean {
+	const cappedReason =
+		turn.stopReason === null ||
+		turn.stopReason === undefined ||
+		turn.stopReason === 'None' ||
+		turn.stopReason === 'max_tokens';
+	return cappedReason && (turn.outputTokens ?? 0) > 0;
+}
+
+/** Read `stop_reason` defensively as a string-or-null (pi may emit `None`/`null`). */
+function readStopReason(raw: unknown): string | null | undefined {
+	if (raw === null) {
+		return null;
+	}
+	if (typeof raw === 'string') {
+		return raw;
+	}
+	return undefined;
+}
+
+/** Read the produced output-token count from `usage.output` OR `usage.output_tokens`. */
+function readOutputTokens(raw: unknown): number | undefined {
+	if (typeof raw !== 'object' || raw === null) {
+		return undefined;
+	}
+	const usage = raw as Record<string, unknown>;
+	const value = usage.output ?? usage.output_tokens;
+	return typeof value === 'number' ? value : undefined;
 }
 
 export interface SessionTailerOptions {