@oh-my-pi/pi-coding-agent 14.5.14 → 14.6.0

package/src/autoresearch/tools/update-notes.ts

@@ -0,0 +1,116 @@
+import { Text } from "@oh-my-pi/pi-tui";
+import { Type } from "@sinclair/typebox";
+import type { ToolDefinition } from "../../extensibility/extensions";
+import type { Theme } from "../../modes/theme/theme";
+import { replaceTabs, truncateToWidth } from "../../tools/render-utils";
+import * as git from "../../utils/git";
+import { buildExperimentState } from "../state";
+import { openAutoresearchStorageIfExists } from "../storage";
+import type { AutoresearchToolFactoryOptions } from "../types";
+
+const updateNotesSchema = Type.Object({
+	body: Type.String({
+		description: "Replacement markdown body for the active autoresearch session's notes (your durable playbook).",
+	}),
+	append_idea: Type.Optional(
+		Type.String({
+			description:
+				"When set, append this string as a new bullet under an Ideas section instead of replacing the body. `body` is ignored.",
+		}),
+	),
+});
+
+interface UpdateNotesDetails {
+	notes: string;
+}
+
+export function createUpdateNotesTool(
+	options: AutoresearchToolFactoryOptions,
+): ToolDefinition<typeof updateNotesSchema, UpdateNotesDetails> {
+	return {
+		name: "update_notes",
+		label: "Update Notes",
+		description:
+			"Persist the durable autoresearch playbook (goal, scope notes, hypotheses, ideas backlog) on the active session. Pass `body` to replace the entire notes blob, or `append_idea` to append a single bullet under an `## Ideas` section.",
+		parameters: updateNotesSchema,
+		defaultInactive: true,
+		async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
+			const storage = await openAutoresearchStorageIfExists(ctx.cwd);
+			const currentBranch = (await git.branch.current(ctx.cwd)) ?? null;
+			const session = storage?.getActiveSessionForBranch(currentBranch) ?? null;
+			if (!storage || !session) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "Error: no active autoresearch session for the current branch. Call init_experiment first.",
+						},
+					],
+				};
+			}
+
+			const nextNotes =
+				params.append_idea !== undefined && params.append_idea.trim().length > 0
+					? appendIdea(session.notes, params.append_idea.trim())
+					: params.body;
+
+			storage.updateSession(session.id, { notes: nextNotes });
+			const refreshed = storage.getSessionById(session.id);
+			const loggedRuns = storage.listLoggedRuns(session.id);
+			const runtime = options.getRuntime(ctx);
+			if (refreshed) {
+				runtime.state = buildExperimentState(refreshed, loggedRuns);
+			}
+			options.dashboard.updateWidget(ctx, runtime);
+
+			return {
+				content: [
+					{
+						type: "text",
+						text:
+							params.append_idea !== undefined
+								? `Appended idea (${nextNotes.length} chars total).`
+								: `Notes updated (${nextNotes.length} chars).`,
+					},
+				],
+				details: { notes: nextNotes },
+			};
+		},
+		renderCall(args, _options, theme): Text {
+			const preview = args.append_idea ?? args.body.slice(0, 100);
+			return new Text(
+				`${theme.fg("toolTitle", theme.bold("update_notes"))} ${theme.fg("muted", truncateToWidth(replaceTabs(preview), 100))}`,
+				0,
+				0,
+			);
+		},
+		renderResult(result, _options, theme: Theme): Text {
+			const text = replaceTabs(result.content.find(part => part.type === "text")?.text ?? "");
+			return new Text(theme.fg("muted", text), 0, 0);
+		},
+	};
+}
+
+const IDEAS_HEADING = "## Ideas";
+
+function appendIdea(currentNotes: string, idea: string): string {
+	const trimmed = currentNotes.trimEnd();
+	if (trimmed.length === 0) {
+		return `${IDEAS_HEADING}\n- ${idea}\n`;
+	}
+	if (trimmed.includes(IDEAS_HEADING)) {
+		const lines = trimmed.split("\n");
+		const ideasIndex = lines.findIndex(line => line.trim() === IDEAS_HEADING);
+		// find end of ideas section (next heading or end of file)
+		let insertAt = lines.length;
+		for (let i = ideasIndex + 1; i < lines.length; i += 1) {
+			if (/^#{1,6}\s/.test(lines[i] ?? "")) {
+				insertAt = i;
+				break;
+			}
+		}
+		lines.splice(insertAt, 0, `- ${idea}`);
+		return `${lines.join("\n")}\n`;
+	}
+	return `${trimmed}\n\n${IDEAS_HEADING}\n- ${idea}\n`;
+}

package/src/autoresearch/types.ts

@@ -21,21 +21,6 @@ export interface MetricDef {
 	unit: string;
 }
 
-export interface AutoresearchBenchmarkContract {
-	command: string | null;
-	primaryMetric: string | null;
-	metricUnit: string;
-	direction: MetricDirection | null;
-	secondaryMetrics: string[];
-}
-
-export interface AutoresearchContract {
-	benchmark: AutoresearchBenchmarkContract;
-	scopePaths: string[];
-	offLimits: string[];
-	constraints: string[];
-}
-
 export interface ExperimentResult {
 	runNumber: number | null;
 	commit: string;
@@ -47,6 +32,11 @@ export interface ExperimentResult {
 	segment: number;
 	confidence: number | null;
 	asi?: ASIData;
+	modifiedPaths: string[];
+	scopeDeviations: string[];
+	justification: string | null;
+	flagged: boolean;
+	flaggedReason: string | null;
 }
 
 export interface ExperimentState {
@@ -57,13 +47,17 @@ export interface ExperimentState {
 	metricUnit: string;
 	secondaryMetrics: MetricDef[];
 	name: string | null;
+	goal: string | null;
 	currentSegment: number;
 	maxExperiments: number | null;
 	confidence: number | null;
-	benchmarkCommand: string | null;
 	scopePaths: string[];
 	offLimits: string[];
 	constraints: string[];
+	notes: string;
+	branch: string | null;
+	baselineCommit: string | null;
+	sessionId: number | null;
 }
 
 export interface RunExperimentProgressDetails {
@@ -78,7 +72,6 @@ export interface RunDetails {
 	runNumber: number;
 	runDirectory: string;
 	benchmarkLogPath: string;
-	checksLogPath?: string;
 	command: string;
 	exitCode: number | null;
 	durationSeconds: number;
@@ -86,16 +79,13 @@ export interface RunDetails {
 	crashed: boolean;
 	timedOut: boolean;
 	tailOutput: string;
-	checksPass: boolean | null;
-	checksTimedOut: boolean;
-	checksOutput: string;
-	checksDuration: number;
 	parsedMetrics: NumericMetricMap | null;
 	parsedPrimary: number | null;
 	parsedAsi: ASIData | null;
 	metricName: string;
 	metricUnit: string;
 	preRunDirtyPaths: string[];
+	abandonedPriorRun: number | null;
 	truncation?: TruncationResult;
 	fullOutputPath?: string;
 }
@@ -104,18 +94,12 @@ export interface LogDetails {
 	experiment: ExperimentResult;
 	state: ExperimentState;
 	wallClockSeconds: number | null;
-}
-
-export interface ChecksResult {
-	pass: boolean;
-	output: string;
-	duration: number;
+	scopeDeviations: string[];
+	justification: string | null;
+	flaggedRuns: Array<{ runId: number; reason: string }>;
 }
 
 export interface PendingRunSummary {
-	checksDurationSeconds: number | null;
-	checksPass: boolean | null;
-	checksTimedOut: boolean;
 	command: string;
 	durationSeconds: number | null;
 	parsedAsi: ASIData | null;
@@ -125,6 +109,8 @@ export interface PendingRunSummary {
 	preRunDirtyPaths: string[];
 	runDirectory: string;
 	runNumber: number;
+	exitCode: number | null;
+	timedOut: boolean;
 }
 
 export interface RunningExperiment {
@@ -139,7 +125,6 @@ export interface AutoresearchRuntime {
 	autoResumeArmed: boolean;
 	dashboardExpanded: boolean;
 	lastAutoResumePendingRunNumber: number | null;
-	lastRunChecks: ChecksResult | null;
 	lastRunDuration: number | null;
 	lastRunAsi: ASIData | null;
 	lastRunArtifactDir: string | null;
@@ -150,41 +135,6 @@ export interface AutoresearchRuntime {
 	goal: string | null;
 }
 
-export interface AutoresearchConfig {
-	maxIterations?: number;
-	workingDir?: string;
-}
-
-export interface AutoresearchJsonConfigEntry {
-	type: "config";
-	name?: string;
-	metricName?: string;
-	metricUnit?: string;
-	bestDirection?: MetricDirection;
-	benchmarkCommand?: string;
-	secondaryMetrics?: string[];
-	scopePaths?: string[];
-	offLimits?: string[];
-	constraints?: string[];
-}
-
-export interface AutoresearchJsonRunEntry {
-	run?: number;
-	commit?: string;
-	metric?: number;
-	metrics?: NumericMetricMap;
-	status?: ExperimentStatus;
-	description?: string;
-	timestamp?: number;
-	confidence?: number | null;
-	asi?: ASIData;
-}
-
-export interface ReconstructedExperimentData {
-	hasLog: boolean;
-	state: ExperimentState;
-}
-
 export interface AutoresearchControlEntryData {
 	mode: "on" | "off" | "clear";
 	goal?: string;

package/src/config/settings-schema.ts

@@ -973,7 +973,7 @@ export const SETTINGS_SCHEMA = {
 		ui: {
 			tab: "editing",
 			label: "Edit Mode",
-			description: "Select the edit tool variant (replace, patch, hashline, atom, vim, or apply_patch)",
+			description: "Select the edit tool variant (replace, patch, hashline, vim, or apply_patch)",
 		},
 	},
 

package/src/config/settings.ts

@@ -326,7 +326,7 @@ export class Settings {
 
 	/**
 	 * Get the edit variant for a specific model.
-	 * Returns "patch", "replace", "hashline", "atom", "vim", "apply_patch", or null (use global default).
+	 * Returns "patch", "replace", "hashline", "vim", "apply_patch", or null (use global default).
 	 */
 	getEditVariantForModel(model: string | undefined): EditMode | null {
 		if (!model) return null;
@@ -533,6 +533,25 @@ export class Settings {
 			delete isolationObj.enabled;
 		}
 
+		// edit.mode: removed "atom" variant is now "hashline"
+		const editObj = raw.edit as Record<string, unknown> | undefined;
+		if (editObj) {
+			if (editObj.mode === "atom") {
+				editObj.mode = "hashline";
+			}
+			const modelVariants = editObj.modelVariants as Record<string, unknown> | undefined;
+			if (modelVariants && typeof modelVariants === "object" && !Array.isArray(modelVariants)) {
+				for (const [pattern, variant] of Object.entries(modelVariants)) {
+					if (variant === "atom") {
+						modelVariants[pattern] = "hashline";
+					}
+				}
+			}
+		}
+		if (raw["edit.mode"] === "atom") {
+			raw["edit.mode"] = "hashline";
+		}
+
 		// statusLine: rename "plan_mode" segment to "mode"
 		const statusLineObj = raw.statusLine as Record<string, unknown> | undefined;
 		if (statusLineObj) {

package/src/cursor.ts

@@ -180,7 +180,7 @@ export class CursorExecHandlers implements ICursorExecHandlers {
 		const searchPath = args.glob ? `${args.path || "."}/${args.glob}` : args.path || ".";
 		const toolResultMessage = await executeTool(this.options, "search", toolCallId, {
 			pattern: args.pattern,
-			path: searchPath,
+			paths: [searchPath],
 			i: args.caseInsensitive || undefined,
 		});
 		return toolResultMessage;

package/src/edit/index.ts

@@ -9,7 +9,6 @@ import {
 	writethroughNoop,
 } from "../lsp";
 import applyPatchDescription from "../prompts/tools/apply-patch.md" with { type: "text" };
-import atomDescription from "../prompts/tools/atom.md" with { type: "text" };
 import hashlineDescription from "../prompts/tools/hashline.md" with { type: "text" };
 import patchDescription from "../prompts/tools/patch.md" with { type: "text" };
 import replaceDescription from "../prompts/tools/replace.md" with { type: "text" };
@@ -17,17 +16,16 @@ import type { ToolSession } from "../tools";
 import { VimTool, vimSchema } from "../tools/vim";
 import { type EditMode, normalizeEditMode, resolveEditMode } from "../utils/edit-mode";
 import type { VimToolDetails } from "../vim/types";
+import { resolveLarkLidPlaceholders } from "./line-hash";
 import { type ApplyPatchParams, applyPatchSchema, expandApplyPatchToEntries } from "./modes/apply-patch";
 import applyPatchGrammar from "./modes/apply-patch.lark" with { type: "text" };
-import { type AtomParams, atomEditParamsSchema, executeAtomSingle } from "./modes/atom";
-import atomGrammar from "./modes/atom.lark" with { type: "text" };
 import {
 	executeHashlineSingle,
 	HashlineMismatchError,
 	type HashlineParams,
-	type HashlineToolEdit,
 	hashlineEditParamsSchema,
 } from "./modes/hashline";
+import hashlineGrammarTemplate from "./modes/hashline.lark" with { type: "text" };
 import { executePatchSingle, type PatchEditEntry, type PatchParams, patchEditSchema } from "./modes/patch";
 import { executeReplaceSingle, type ReplaceEditEntry, type ReplaceParams, replaceEditSchema } from "./modes/replace";
 import { type EditToolDetails, type EditToolPerFileResult, getLspBatchRequest, type LspBatchRequest } from "./renderer";
@@ -36,8 +34,11 @@ export { DEFAULT_EDIT_MODE, type EditMode, normalizeEditMode } from "../utils/ed
 export * from "./apply-patch";
 export * from "./diff";
 export * from "./line-hash";
+
+// Resolve the `$HASHFMT$` placeholder in the hashline Lark grammar.
+const hashlineGrammar = resolveLarkLidPlaceholders(hashlineGrammarTemplate);
+
 export * from "./modes/apply-patch";
-export * from "./modes/atom";
 export * from "./modes/hashline";
 export * from "./modes/patch";
 export * from "./modes/replace";
@@ -49,12 +50,11 @@ type TInput =
 	| typeof replaceEditSchema
 	| typeof patchEditSchema
 	| typeof hashlineEditParamsSchema
-	| typeof atomEditParamsSchema
 	| typeof vimSchema
 	| typeof applyPatchSchema;
 
 type VimParams = Static<typeof vimSchema>;
-type EditParams = ReplaceParams | PatchParams | HashlineParams | AtomParams | VimParams | ApplyPatchParams;
+type EditParams = ReplaceParams | PatchParams | HashlineParams | VimParams | ApplyPatchParams;
 type EditToolResultDetails = EditToolDetails | VimToolDetails;
 
 type EditModeDefinition = {
@@ -292,7 +292,7 @@ export class EditTool implements AgentTool<TInput> {
 	 */
 	get customFormat(): { syntax: "lark"; definition: string } | undefined {
 		if (this.mode === "apply_patch") return { syntax: "lark", definition: applyPatchGrammar };
-		if (this.mode === "atom") return { syntax: "lark", definition: atomGrammar };
+		if (this.mode === "hashline") return { syntax: "lark", definition: hashlineGrammar };
 		return undefined;
 	}
 
@@ -390,30 +390,8 @@ export class EditTool implements AgentTool<TInput> {
 					batchRequest: LspBatchRequest | undefined,
 					_onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
 				) => {
-					const { edits, path } = params as HashlineParams;
+					const { input, path } = params as HashlineParams & { path?: string };
 					return executeHashlineSingle({
-						session: tool.session,
-						path,
-						edits: edits as HashlineToolEdit[],
-						signal,
-						batchRequest,
-						writethrough: tool.#writethrough,
-						beginDeferredDiagnosticsForPath: p => tool.#beginDeferredDiagnosticsForPath(p),
-					});
-				},
-			},
-			atom: {
-				description: () => prompt.render(atomDescription),
-				parameters: atomEditParamsSchema,
-				execute: (
-					tool: EditTool,
-					params: EditParams,
-					signal: AbortSignal | undefined,
-					batchRequest: LspBatchRequest | undefined,
-					_onUpdate?: (partialResult: AgentToolResult<EditToolDetails, TInput>) => void,
-				) => {
-					const { input, path } = params as AtomParams & { path?: string };
-					return executeAtomSingle({
 						session: tool.session,
 						input,
 						path,

package/src/edit/line-hash.ts

@@ -668,66 +668,93 @@ export const HASHLINE_BIGRAMS = [
 export const HASHLINE_BIGRAMS_COUNT = HASHLINE_BIGRAMS.length;
 
 /**
- * Regex source matching exactly one bigram from {@link HASHLINE_BIGRAMS}.
- * Used by hashline parsers — keep in sync with the alphabet array above.
+ * Decoration prefix that may precede a `LINE+HASH` anchor in tool output:
+ * `>` (context line in grep), `+` (added line in diff), `-` (removed line),
+ * `*` (match line). Any combination, in any order, surrounded by optional
+ * whitespace. Output formatters emit at most one decoration per anchor; the
+ * regex stays liberal because anchor-ref parsers accept whatever the model
+ * echoes back.
  */
-export const HASHLINE_BIGRAM_RE_SRC = `(?:${HASHLINE_BIGRAMS.join("|")})`;
+export const HASHLINE_ANCHOR_DECORATION_RE_SRC = `\\s*[>+\\-*]*\\s*`;
 
-export const HASHLINE_CONTENT_SEPARATOR = "|";
+/**
+ * Capture-group regex source for a decorated `LINE+HASH` anchor. Group 1
+ * captures the line number (digits only); group 2 captures the hash. The
+ * source is intentionally unanchored — anchoring with `^` (or composing into a
+ * larger pattern) is the caller's responsibility.
+ */
+export const HASHLINE_ANCHOR_RE_SRC = `${HASHLINE_ANCHOR_DECORATION_RE_SRC}(\\d+)([a-z]{2})`;
 
-const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
-const RE_STRUCTURAL_STRIP = /[\s{}]/g;
+/**
+ * Bare `LINE+HASH` Lid (no decorations, no captures, no anchors). Use for
+ * embedding inside larger patterns where the line+hash unit appears as a
+ * literal (e.g. range bounds, alternation arms, op-line heuristics).
+ */
+export const HASHLINE_LID_RE_SRC = `[1-9]\\d*[a-z]{2}`;
+
+/**
+ * Capture-group form of {@link HASHLINE_LID_RE_SRC}: group 1 captures the
+ * line number, group 2 captures the hash.
+ */
+export const HASHLINE_LID_CAPTURE_RE_SRC = `([1-9]\\d*)([a-z]{2})`;
+
+/** Width of a hash in display characters. */
+export const HASHLINE_HASH_WIDTH = 2;
+
+/**
+ * Representative hash suffixes for use in user-facing error messages and
+ * prompt examples.
+ */
+export const HASHLINE_HASH_EXAMPLES = ["sr", "ab", "th"] as const;
 
 /**
- * Bigram returned for lines that contain only whitespace and `{`/`}`.
- * Picks the English ordinal suffix for the line number (`1` → `st`,
- * `2` → `nd`, `3` → `rd`, `11`/`12`/`13` → `th`, else `th`) so the
- * line digits + bigram BPE-merge into a single ordinal token (`1st`, `42nd`,
- * `100th`, …). Brace-only lines therefore cost one token for the whole
- * `LINE+ID` anchor instead of two.
+ * Format a comma-separated list of example anchors with an optional line-number
+ * prefix, quoted for inclusion in error messages: `"160sr", "160ab", "160th"`.
  */
-function structuralBigram(line: number): string {
-	const mod100 = line % 100;
-	if (mod100 >= 11 && mod100 <= 13) return "th";
-	switch (line % 10) {
-		case 1:
-			return "st";
-		case 2:
-			return "nd";
-		case 3:
-			return "rd";
-		default:
-			return "th";
-	}
+export function describeAnchorExamples(linePrefix = ""): string {
+	return HASHLINE_HASH_EXAMPLES.map(e => `"${linePrefix}${e}"`).join(", ");
 }
 
 /**
- * Compute a short BPE-bigram hash of a single line.
+ * Sentinel token that the hashline Lark grammar uses for the hash
+ * regex source. Replaced at module-load time by {@link resolveLarkLidPlaceholders}
+ * so the grammar is re-derived from a single source of truth alongside its
+ * TypeScript consumers. Update the placeholder name here and in the grammar together.
+ */
+export const LARK_LID_HASH_PLACEHOLDER = "$HASHFMT$";
+
+/**
+ * Substitute the LID hash placeholder in a Lark grammar text with the
+ * `[a-z]{2}` hash regex source. Grammars that don't reference Lids pass
+ * through unchanged.
+ */
+export function resolveLarkLidPlaceholders(grammar: string): string {
+	return grammar.replaceAll(LARK_LID_HASH_PLACEHOLDER, "[a-z]{2}");
+}
+
+export const HASHLINE_CONTENT_SEPARATOR = "|";
+
+const RE_SIGNIFICANT = /[\p{L}\p{N}]/u;
+
+/**
+ * Compute a 2-character hash of a single line via xxHash32 mod 647 over
+ * {@link HASHLINE_BIGRAMS}. Lines with no letter or digit (e.g. bare `}`,
+ * bare `{`) mix the line number into the seed so adjacent identical
+ * brace-only lines get distinct hashes; lines with significant content stay
+ * line-number-independent so a line is identifiable across small shifts.
  *
- * Uses xxHash32 on a trailing-whitespace-trimmed, CR-stripped line, mapped into
- * {@link HASHLINE_BIGRAMS} via modulo. Lines that contain only whitespace and
- * `{`/`}` collapse to an ordinal-suffix bigram (see {@link structuralBigram})
- * so brace-only structure shares one merged ordinal token. For other lines
- * containing no alphanumeric characters, the line number is mixed in to reduce hash collisions.
  * The line input should not include a trailing newline.
  */
 export function computeLineHash(idx: number, line: string): string {
 	line = line.replace(/\r/g, "").trimEnd();
-
-	if (line.replace(RE_STRUCTURAL_STRIP, "").length === 0) {
-		return structuralBigram(idx);
-	}
-
-	let seed = 0;
-	if (!RE_SIGNIFICANT.test(line)) {
-		seed = idx;
-	}
+	const seed = RE_SIGNIFICANT.test(line) ? 0 : idx;
 	return HASHLINE_BIGRAMS[Bun.hash.xxHash32(line, seed) % HASHLINE_BIGRAMS_COUNT];
 }
 
 /**
  * Formats an anchor reference given a line number and its text.
- * Returns `LINE+ID` (e.g., `42nd`) — no separator between number and bigram.
+ * Returns `LINE+ID` (e.g., `42sr`) — no separator between
+ * number and hash.
  */
 export function formatLineHash(line: number, lines: string): string {
 	return `${line}${computeLineHash(line, lines)}`;
@@ -735,7 +762,7 @@ export function formatLineHash(line: number, lines: string): string {
 
 /**
  * Formats a single line with a hashline anchor.
- * Returns `LINE+ID|TEXT` (e.g., `42nd|function hi() {\n2er|  return;\n3in|}`)
+ * Returns `LINE+ID|TEXT` (e.g., `42sr|function hi() {`, `3ab|}`).
  */
 export function formatHashLine(lineNumber: number, line: string): string {
 	return `${lineNumber}${computeLineHash(lineNumber, line)}${HASHLINE_CONTENT_SEPARATOR}${line}`;
@@ -754,7 +781,7 @@ export function formatHashLine(lineNumber: number, line: string): string {
  * @example
  * ```
  * formatHashLines("function hi() {\n  return;\n}")
- * // "1th|function hi() {\n2er|  return;\n3in|}"
+ * // "1bm|function hi() {\n2er|  return;\n3ab|}"
  * ```
  */
 export function formatHashLines(text: string, startLine = 1): string {

package/src/edit/modes/hashline.lark

@@ -0,0 +1,26 @@
+%import common.LF
+
+start: section+
+
+section: file_header line_op*
+
+file_header: "@" path LF
+
+line_op: insert_before_op payload+
+       | insert_after_op payload+
+       | replace_op payload*
+       | delete_op
+       | blank
+
+insert_before_op: "<" insert_target LF
+insert_after_op: "+" insert_target LF
+replace_op: "=" range LF
+delete_op: "-" range LF
+payload: "|" /[^\r\n]*/ LF
+
+insert_target: LID | "EOF" | "BOF"
+range: LID (".." LID)?
+
+path: /(?:[^\s\r\n]+|"[^"\r\n]+"|'[^'\r\n]+')/
+LID: /[1-9][0-9]*$HASHFMT$/
+blank: LF