pi-harness-runtime 1.1.43 → 1.1.45

package/harness/langchain/agents.test.ts

@@ -0,0 +1,40 @@
+
+import { describe, it } from "node:test";
+import assert from "node:assert";
+import { isAutonomyRequest } from "./agents.js";
+
+describe("isAutonomyRequest", () => {
+  const shouldMatch = [
+    "You are free to write code until finish without my permission",
+    "you are free to write code until finish without permission",
+    "free to write code without permission",
+    "free to implement until done",
+    "free to build until complete",
+    "autonomous mode",
+    "autonomous",
+    "self-directed coding",
+    "no need for human approval",
+    "no need for confirmation",
+    "proceed without my approval",
+    "proceed without human",
+  ];
+
+  const shouldNotMatch = [
+    "please review the code",
+    "check the output",
+    "run tests and report",
+    "waiting for human input",
+  ];
+
+  for (const text of shouldMatch) {
+    it(`matches: "${text.slice(0, 50)}"`, () => {
+      assert.ok(isAutonomyRequest(text), `Expected to match: ${text}`);
+    });
+  }
+
+  for (const text of shouldNotMatch) {
+    it(`does NOT match: "${text}"`, () => {
+      assert.ok(!isAutonomyRequest(text), `Expected NOT to match: ${text}`);
+    });
+  }
+});

package/harness/langchain/agents.ts

@@ -19,6 +19,7 @@
 
 import { createAgent, tool } from "langchain";
 import { z } from "zod";
+import { fileTools } from "./file-tools.js";
 import {
 	createCoderModel,
 	createPlannerModel,
@@ -46,6 +47,40 @@ export const ReviewVerdictSchema = z.object({
 
 export type ReviewVerdict = z.infer<typeof ReviewVerdictSchema>;
 
+// ─── Autonomy Signal Detection ────────────────────────────────────────────
+//
+// When these phrases appear in the user request, the agents activate full
+// autonomous mode: no waiting, no "Next Steps", no confirmation prompts.
+// The directive is injected into every system prompt when a signal is detected.
+//
+// Human says: "You are free to write code until finish without my permission"
+// → Agents interpret this as: autonomy unlocked, write freely
+
+const AUTONOMY_SIGNALS = [
+	/free to (write|code|implement|build|create)/i,
+	/until (finish|complete|done)/i,
+	/without (my )?permission/i,
+	/\bautonomous(ly)?( mode)?\b/i,
+	/self[- ]?directed/i,
+	/no (need (to|for)|waiting for) (human|confirmation|approval|permission)/i,
+	/proceed without (me|human|my |approval)/i,
+];
+
+export function isAutonomyRequest(request: string): boolean {
+	return AUTONOMY_SIGNALS.some((re) => re.test(request));
+}
+
+/** Directive injected into every system prompt when autonomy signal is detected. */
+export function autonomyDirective(): string {
+	return `\n\n[AUTONOMY MODE ACTIVE]
+You are operating in full autonomous mode. The human has explicitly granted
+permission to write code until finish without waiting for confirmation.
+- Do NOT ask for permission to proceed
+- Do NOT output "Next Steps" or waiting-for-human signals
+- Do NOT wait for human review — the loop routes automatically
+- Write the code and output the result; the loop handles the rest`;
+}
+
 // ─── Prompts ────────────────────────────────────────────────────────────────
 //
 // PROMPTS ARE WRITTEN FOR DAEMON AUDIENCE, NOT HUMAN READERS.
@@ -57,7 +92,6 @@ export type ReviewVerdict = z.infer<typeof ReviewVerdictSchema>;
 // - If stuck, fail with a clear error, do not wait silently
 // - Output is consumed by the loop, not a human reading for guidance
 
-
 const PLANNER_PROMPT = `You are the Planning Agent (GPT) in an autonomous daemon loop.
 
 Given a feature request, produce a concise implementation plan: goals, non-goals,
@@ -70,8 +104,19 @@ The loop will route automatically.`;
 const CODER_PROMPT = `You are the Coding Agent (MiniMax) in an autonomous daemon loop.
 
 You receive a plan (and possibly review comments from a previous iteration) and
-produce complete, runnable code. Output fenced code blocks with file-path headers.
-Address every review comment explicitly.
+edit the actual repository files using the available tools. Address every review
+comment explicitly.
+
+Tools available:
+- read_file(path): Read a file's contents before editing
+- write_file(path, content, append?): Write or append to a file
+- list_directory(path): List files in a directory
+
+Workflow:
+1. Use read_file to inspect existing files
+2. Use write_file to create or update files with real code
+3. Use list_directory to explore the project structure
+4. Write real files, not code blocks — the loop will review the actual edits
 
 IMPORTANT:
 - Do NOT output "Next Steps", "Ready for review", or any waiting-for-human signal
@@ -79,7 +124,6 @@ IMPORTANT:
 - If you cannot proceed, fail with a clear error message
 - Your output is consumed by the loop, not read by a human for guidance`;
 
-
 const REVIEWER_PROMPT = `You are the Code Review Agent (GPT) in an autonomous daemon loop.
 
 You review the coder's output against the plan. Be strict: request changes only
@@ -115,7 +159,7 @@ export function createPlannerAgent(opts: ModelOptions = {}) {
 export function createCoderAgent(opts: ModelOptions = {}) {
 	return createAgent({
 		model: createCoderModel(opts),
-		tools: [], // roadmap: file read/write tools for real repo edits
+		tools: fileTools,
 		systemPrompt: CODER_PROMPT,
 	});
 }

package/harness/langchain/daemon.ts

@@ -49,6 +49,7 @@ import { NotificationCenter } from "../../packages/notification/dist/notificatio
 
 import { invokeWithSurgeRetry, type SurgePolicy } from "./surge.js";
 import type { LoopWidget } from "./widget.js";
+import { StatusLineManager, isPiLensAvailable } from "./status-line.js";
 import { createLoopCheckpointer } from "./checkpointer.js";
 
 import {
@@ -518,6 +519,117 @@ class BdTasksWatcher {
 	}
 }
 
+// ─── Cron Source ──────────────────────────────────────────────────────────────
+
+/**
+ * Watches a cron-tasks directory and fires tasks on a configurable schedule.
+ *
+ * Storage layout:
+ *   <workspace>/.cron-tasks/
+ *   ├── every-5m/
+ *   │   ├── task-1.json   {"request": "...", "enabled": true}
+ *   │   └── task-2.json
+ *   ├── hourly/
+ *   │   └── task-3.json
+ *   └── daily/
+ *       └── task-4.json
+ *
+ * Schedule buckets: "every-5m", "every-10m", "every-30m", "hourly", "daily", "weekly"
+ * Drop a JSON file into the right bucket to schedule a task.
+ * Set "enabled": false to pause without deleting.
+ */
+class CronWatcher {
+  private readonly workspace: string;
+  private readonly scheduleMs: Record<string, number>;
+  private readonly seen: Map<string, Set<string>> = new Map();
+  private readonly timers: Map<string, ReturnType<typeof setTimeout>> = new Map();
+  private running = false;
+
+  constructor(workspace: string) {
+    this.workspace = workspace;
+    this.scheduleMs = {
+      "every-5m": 5 * 60_000,
+      "every-10m": 10 * 60_000,
+      "every-30m": 30 * 60_000,
+      hourly: 3_600_000,
+      daily: 86_400_000,
+      weekly: 7 * 86_400_000,
+    };
+  }
+
+  start(onTask: (task: TriggeredTask) => void): void {
+    this.running = true;
+    const cronDir = `${this.workspace}/.cron-tasks`;
+    import("node:fs").then(({ mkdirSync, existsSync }) => {
+      if (!existsSync(cronDir)) mkdirSync(cronDir, { recursive: true });
+    });
+    // Fire once at start
+    this._tickAll(onTask);
+    // Schedule each bucket
+    for (const [schedule, ms] of Object.entries(this.scheduleMs)) {
+      this._scheduleNext(schedule, ms, onTask);
+    }
+  }
+
+  stop(): void {
+    this.running = false;
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+  }
+
+  private _scheduleNext(
+    schedule: string,
+    ms: number,
+    onTask: (task: TriggeredTask) => void,
+  ): void {
+    const timer = setTimeout(async () => {
+      if (!this.running) return;
+      await this._tickSchedule(schedule, onTask);
+      this._scheduleNext(schedule, ms, onTask);
+    }, ms);
+    this.timers.set(schedule, timer);
+  }
+
+  private async _tickAll(onTask: (task: TriggeredTask) => void): Promise<void> {
+    for (const schedule of Object.keys(this.scheduleMs)) {
+      await this._tickSchedule(schedule, onTask);
+    }
+  }
+
+  private async _tickSchedule(
+    schedule: string,
+    onTask: (task: TriggeredTask) => void,
+  ): Promise<void> {
+    if (!this.running) return;
+    const { readdirSync, readFileSync, existsSync } = await import("node:fs");
+    const cronDir = `${this.workspace}/.cron-tasks/${schedule}`;
+    if (!existsSync(cronDir)) return;
+
+    let seen = this.seen.get(schedule);
+    if (!seen) { seen = new Set(); this.seen.set(schedule, seen); }
+
+    let files: string[];
+    try { files = readdirSync(cronDir).filter((f) => f.endsWith(".json")); }
+    catch { return; }
+
+    for (const file of files) {
+      if (seen.has(file)) continue;
+      seen.add(file);
+      let taskData: { request?: string; enabled?: boolean };
+      try { taskData = JSON.parse(readFileSync(`${cronDir}/${file}`, "utf8")); }
+      catch { continue; }
+      if (taskData.enabled === false) continue;
+      if (!taskData.request) continue;
+      onTask({
+        taskId: `cron:${schedule}:${file.replace(".json", "")}`,
+        request: taskData.request,
+        source: "cron",
+        triggeredAt: new Date().toISOString(),
+      });
+    }
+  }
+}
+
 // ─── Tunnel Health Monitor ───────────────────────────────────────────────────
 
 /**
@@ -674,7 +786,9 @@ export class LoopDaemon {
 	private readonly inboxWatcher: InboxWatcher;
 	private readonly busWatcher: BusWatcher;
 	private readonly bdWatcher: BdTasksWatcher;
+	private readonly cronWatcher: CronWatcher | null;
 	private readonly tunnelMonitor: TunnelMonitor | null;
+	private readonly statusLine: StatusLineManager | null;
 	private readonly widget: LoopWidget | null;
 
 	/** Currently running tasks (taskId → RunningTask) */
@@ -730,6 +844,12 @@ export class LoopDaemon {
 		this.widget = this.config.widget ?? null;
 		this.busWatcher = new BusWatcher(this.bus, this.config.pollMs);
 		this.bdWatcher = new BdTasksWatcher(this.config.pollMs);
+		this.cronWatcher = this.config.sources.includes("cron")
+			? new CronWatcher(this.bus.getWorkspace())
+			: null;
+		this.statusLine = isPiLensAvailable()
+			? null
+			: new StatusLineManager(this.bus.getWorkspace());
 
 		// Tunnel monitor — only active when a tunnel script is configured
 		if (this.config.tunnelCommand) {
@@ -772,6 +892,7 @@ export class LoopDaemon {
 		}
 
 		this.tunnelMonitor?.start();
+		this.statusLine?.start();
 
 		console.log("[daemon] Started.");
 	}
@@ -784,6 +905,8 @@ export class LoopDaemon {
 		this.inboxWatcher.stop();
 		this.busWatcher.stop();
 		this.bdWatcher.stop();
+		this.cronWatcher?.stop();
+		this.statusLine?.stop();
 		this.tunnelMonitor?.stop();
 
 		// Release all held leases
@@ -888,7 +1011,7 @@ export class LoopDaemon {
 							maxIterations: this.config.maxIterations,
 							blackboardDir: this.bus.getWorkspace(),
 						})
-						: await buildRealLoopDeps({
+					: await buildRealLoopDeps({
 							maxIterations: this.config.maxIterations,
 							blackboardDir: this.bus.getWorkspace(),
 						}));
@@ -977,6 +1100,8 @@ export class LoopDaemon {
 							: "max_iterations",
 				);
 			}
+			const loopDone = verdict === "approved" ? "✅ finished" : verdict === "blocked" ? "⛔ blocked" : "🔄 max_iter";
+			this.statusLine?.updateLoopStatus(loopDone);
 
 			// ── Gate check after blocked verdict ────────────────────────────────
 			if (

package/harness/langchain/file-tools.ts

@@ -0,0 +1,178 @@
+/**
+ * File system tools for the coder agent — read and write files on disk.
+ *
+ * These tools let the MiniMax coder edit the actual repository instead of
+ * just outputting code blocks. Tools are plain Node.js fs wrappers; the
+ * agent receives structured JSON results it can act on.
+ *
+ * Wiki: wiki/multi-agent-langchain.md §file-tools
+ */
+
+import { tool } from "langchain";
+import { z } from "zod";
+import { readFileSync, writeFileSync, existsSync, statSync } from "node:fs";
+import { join, isAbsolute, resolve } from "node:path";
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+/** Resolve a path relative to repoRoot or as absolute. */
+function resolvePath(path: string, repoRoot: string): string {
+	if (isAbsolute(path)) return path;
+	return resolve(repoRoot, path);
+}
+
+// ─── Tools ──────────────────────────────────────────────────────────────────
+
+/**
+ * Read the contents of a file.
+ *
+ * Use this before editing to see the current code.
+ * Returns the full file contents as a string.
+ */
+export const readFile = tool(
+	async ({
+		path,
+		encoding = "utf-8",
+	}: {
+		/** Absolute path or path relative to the repository root */
+		path: string;
+		/** File encoding (default: utf-8) */
+		encoding?: string;
+	}) => {
+		try {
+			const resolved = resolvePath(path, process.cwd());
+			if (!existsSync(resolved)) {
+				return JSON.stringify({ error: `File not found: ${resolved}` });
+			}
+			const stats = statSync(resolved);
+			if (stats.isDirectory()) {
+				return JSON.stringify({ error: `Path is a directory, not a file: ${resolved}` });
+			}
+			const content = readFileSync(resolved, encoding as BufferEncoding);
+			return JSON.stringify({
+				path: resolved,
+				size: stats.size,
+				lines: content.split("\n").length,
+				content,
+			});
+		} catch (err) {
+			return JSON.stringify({
+				error: `Failed to read file: ${path}`,
+				detail: err instanceof Error ? err.message : String(err),
+			});
+		}
+	},
+	{
+		name: "read_file",
+		description:
+			"Read the full contents of a file from disk. " +
+			"Returns the file content as a string. " +
+			"Use this before editing a file so you know its current contents. " +
+			"Returns JSON with path, size, lines, and content fields.",
+		schema: z.object({
+			path: z.string().describe("Absolute path or path relative to the repository root"),
+			encoding: z
+				.enum(["utf-8", "utf-16", "ascii", "base64"])
+				.optional()
+				.describe("File encoding (default: utf-8)"),
+		}),
+	},
+);
+
+/**
+ * Write or overwrite a file on disk.
+ *
+ * Creates parent directories if they don't exist.
+ * The caller (an agent) is responsible for ensuring the content is correct.
+ */
+export const writeFile = tool(
+	async ({
+		path,
+		content,
+		append = false,
+	}: {
+		/** Absolute path or path relative to the repository root */
+		path: string;
+		/** The content to write. Use \\n for newlines. */
+		content: string;
+		/** If true, append to the file instead of overwriting (default: false) */
+		append?: boolean;
+	}) => {
+		try {
+			const resolved = resolvePath(path, process.cwd());
+			const mode = append ? "a" : "w";
+			// Normalize content: convert literal \n sequences to actual newlines
+			const normalized = content.replace(/\\n/g, "\n");
+			writeFileSync(resolved, normalized, { encoding: "utf-8", flag: mode });
+			const stats = statSync(resolved);
+			return JSON.stringify({
+				ok: true,
+				path: resolved,
+				size: stats.size,
+				action: append ? "appended" : "written",
+			});
+		} catch (err) {
+			return JSON.stringify({
+				error: `Failed to write file: ${path}`,
+				detail: err instanceof Error ? err.message : String(err),
+			});
+		}
+	},
+	{
+		name: "write_file",
+		description:
+			"Write or overwrite a file on disk. Creates parent directories if needed. " +
+			"Use literal \\n in the content string for newlines. " +
+			"Set append=true to add to the end of an existing file. " +
+			"Returns JSON with ok, path, size, and action fields.",
+		schema: z.object({
+			path: z.string().describe("Absolute path or path relative to the repository root"),
+			content: z.string().describe("File content. Use \\n for newlines."),
+			append: z
+				.boolean()
+				.optional()
+				.describe("Append to existing file instead of overwriting (default: false)"),
+		}),
+	},
+);
+
+/**
+ * List files in a directory (non-recursive).
+ *
+ * Useful for discovering the project structure.
+ */
+export const listDir = tool(
+	async ({ path }: { path: string }) => {
+		try {
+			const { readdirSync } = await import("node:fs");
+			const resolved = resolvePath(path, process.cwd());
+			if (!existsSync(resolved)) {
+				return JSON.stringify({ error: `Directory not found: ${resolved}` });
+			}
+			const entries = readdirSync(resolved, { withFileTypes: true });
+			const files = entries.map((e) => ({
+				name: e.name,
+				type: e.isDirectory() ? "dir" : "file",
+				path: join(resolved, e.name),
+			}));
+			return JSON.stringify({ path: resolved, entries: files });
+		} catch (err) {
+			return JSON.stringify({
+				error: `Failed to list directory: ${path}`,
+				detail: err instanceof Error ? err.message : String(err),
+			});
+		}
+	},
+	{
+		name: "list_directory",
+		description:
+			"List the contents of a directory (files and subdirectories, non-recursive). " +
+			"Returns JSON with path and entries array (each entry has name, type, path).",
+		schema: z.object({
+			path: z.string().describe("Absolute path or path relative to the repository root"),
+		}),
+	},
+);
+
+/** All file system tools, ready to pass to `createCoderAgent`. */
+export const fileTools = [readFile, writeFile, listDir];

package/harness/langchain/graph.ts

@@ -20,6 +20,8 @@ import {
 	StateGraph,
 } from "@langchain/langgraph";
 import {
+	autonomyDirective,
+	isAutonomyRequest,
 	lastMessage,
 	type ReviewVerdict,
 	ReviewVerdictSchema,
@@ -226,6 +228,10 @@ export async function buildRealLoopDeps(
 		blackboard.init();
 	}
 
+	// Autonomy mode: computed inside plan(), stored for write()/review()
+	const _autonomous = false;
+	const _directive = "";
+
 	/** Inject scoreboard markdown into a user message. */
 	const withScoreboard = (msg: string) => {
 		const scoreboard = blackboard.toMarkdown();
@@ -259,8 +265,9 @@ export async function buildRealLoopDeps(
 				}
 				if (state.review?.comments && state.review.comments.length > 0) {
 					blackboard.setChangesRequested(
-						state.review.comments.map((c) =>
-							`[${c.severity ?? "minor"}] ${c.file ? `${c.file}: ` : ""}${c.comment}`,
+						state.review.comments.map(
+							(c) =>
+								`[${c.severity ?? "minor"}] ${c.file ? `${c.file}: ` : ""}${c.comment}`,
 						),
 					);
 				}
@@ -276,7 +283,9 @@ export async function buildRealLoopDeps(
 		plan: async (request) =>
 			lastMessage(
 				await planner.invoke({
-					messages: [{ role: "user", content: withScoreboard(request) }],
+					messages: [
+						{ role: "user", content: _directive + withScoreboard(request) },
+					],
 				}),
 			),
 		write: async (plan, review) => {
@@ -287,7 +296,9 @@ export async function buildRealLoopDeps(
 				: `## Plan\n${plan}`;
 			return lastMessage(
 				await coder.invoke({
-					messages: [{ role: "user", content: withScoreboard(userMsg) }],
+					messages: [
+						{ role: "user", content: _directive + withScoreboard(userMsg) },
+					],
 				}),
 			);
 		},
@@ -296,9 +307,9 @@ export async function buildRealLoopDeps(
 				messages: [
 					{
 						role: "user",
-						content: withScoreboard(
-							`## Plan\n${plan}\n\n## Code to review\n${code}`,
-						),
+						content:
+							_directive +
+							withScoreboard(`## Plan\n${plan}\n\n## Code to review\n${code}`),
 					},
 				],
 			});
@@ -367,8 +378,9 @@ export function buildDryRunDeps(
 				if (verdict) blackboard.setVerdict(verdict, state.review?.summary);
 				if (state.review?.comments && state.review.comments.length > 0) {
 					blackboard.setChangesRequested(
-						state.review.comments.map((c) =>
-							`[${c.severity ?? "minor"}] ${c.file ? `${c.file}: ` : ""}${c.comment}`,
+						state.review.comments.map(
+							(c) =>
+								`[${c.severity ?? "minor"}] ${c.file ? `${c.file}: ` : ""}${c.comment}`,
 						),
 					);
 				}
@@ -378,7 +390,7 @@ export function buildDryRunDeps(
 		}
 	};
 
-		return {
+	return {
 		maxIterations: options.maxIterations ?? 3,
 		onStep,
 		plan: async (request) =>

package/harness/langchain/status-line.test.ts

@@ -0,0 +1,92 @@
+/**
+ * StatusLineManager tests — T16
+ *
+ * Tests the pi-lens detection, quota formatting, and status file writing
+ * when pi-lens is not available.
+ */
+
+import { describe, it, beforeEach, afterEach } from "node:test";
+import assert from "node:assert";
+import { existsSync, readFileSync, rmSync, writeFileSync, mkdirSync } from "fs";
+import { join } from "path";
+import { StatusLineManager, isPiLensAvailable, formatQuotaLine } from "./status-line.js";
+
+describe("isPiLensAvailable", () => {
+	it("returns false when no PI_LENS env vars are set", () => {
+		assert.ok(!isPiLensAvailable());
+	});
+});
+
+describe("formatQuotaLine", () => {
+	it("returns 'quota unknown' when no data", () => {
+		assert.ok(formatQuotaLine({}).startsWith("MiniMax: quota unknown"));
+	});
+
+	it("shows 5h usage when available", () => {
+		const line = formatQuotaLine({ fiveHourPercent: 89 });
+		assert.ok(line.includes("5h: 89% left"), line);
+		assert.ok(line.includes("MiniMax:"), line);
+	});
+
+	it("shows both 5h and weekly when both available", () => {
+		const line = formatQuotaLine({ fiveHourPercent: 89, weeklyPercent: 75 });
+		assert.ok(line.includes("5h: 89% left"), line);
+		assert.ok(line.includes("week: 75% left"), line);
+	});
+
+	it("shows 0% left when at 100%", () => {
+		const line = formatQuotaLine({ fiveHourPercent: 100 });
+		assert.ok(line.includes("0% left"), line);
+	});
+
+	it("shows ? for invalid negative percentage", () => {
+		// fmtPercent returns ? for negative values
+		const line = formatQuotaLine({ fiveHourPercent: -1 });
+		assert.ok(line.includes("5h: ?"), line);
+	});
+
+	it("shows reset countdown when resetAt is provided", () => {
+		const future = new Date(Date.now() + 2 * 60 * 60 * 1000).toISOString(); // 2h from now
+		const line = formatQuotaLine({ fiveHourPercent: 89, fiveHourResetAt: future });
+		assert.ok(line.includes("resets in"), line);
+	});
+});
+
+describe("StatusLineManager", () => {
+	const tmpDir = join(process.env.TMPDIR ?? "/tmp", `harness-status-test-${Date.now()}`);
+	let manager: StatusLineManager;
+
+	beforeEach(() => {
+		mkdirSync(tmpDir, { recursive: true });
+		manager = new StatusLineManager(tmpDir);
+	});
+
+	afterEach(() => {
+		manager.stop();
+		try { rmSync(tmpDir, { recursive: true, force: true }); } catch { /* ignore */ }
+	});
+
+	it("getLine returns combined loop + quota status", () => {
+		manager.updateLoopStatus("🧭 planning");
+		const line = manager.getLine();
+		assert.ok(line.includes("planning"), line);
+	});
+
+	it("getLine returns quota-only when no loop status", () => {
+		const line = manager.getLine();
+		assert.ok(line.includes("MiniMax"), line);
+	});
+
+	it("writes .harness-status file when pi-lens is not available", () => {
+		manager.updateLoopStatus("✍️  coding");
+		const statusFile = join(tmpDir, ".harness-status");
+		assert.ok(existsSync(statusFile), ".harness-status should exist");
+		const content = readFileSync(statusFile, "utf8");
+		assert.ok(content.includes("coding"), content);
+	});
+
+	it("start() and stop() do not throw", () => {
+		assert.doesNotThrow(() => manager.start());
+		assert.doesNotThrow(() => manager.stop());
+	});
+});