@bpinternal/overwatch 0.1.0

package/dist/pickers/index.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pickers_exports = {};
+__export(pickers_exports, {
+  busiestFile: () => import_busiest_file.busiestFile,
+  chain: () => chain,
+  count: () => import_count.count
+});
+module.exports = __toCommonJS(pickers_exports);
+var import_count = require("./count");
+var import_busiest_file = require("./busiest-file");
+const chain = (...steps) => async (signals) => {
+  let current = signals;
+  for (const step of steps) {
+    current = await step(current);
+  }
+  return current;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  busiestFile,
+  chain,
+  count
+});
+//# sourceMappingURL=index.js.map

package/dist/pickers/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/pickers/index.ts"],
+  "sourcesContent": ["import type { Signal } from \"../types\";\n\n/** Chooses which of the sensed signals to act on this run. */\nexport type Picker<TData = unknown> = (\n  signals: Signal<TData>[],\n) => Promise<Signal<TData>[]> | Signal<TData>[];\n\nexport { count } from \"./count\";\nexport { busiestFile } from \"./busiest-file\";\n\n/**\n * Runs pickers left-to-right, each narrowing the output of the previous \u2014 e.g.\n * `chain(busiestFile(), count(3))` focuses one file, then caps it at 3 signals.\n * Order matters: every step only sees what the one before it kept. With no steps\n * it passes the signals through untouched.\n */\nexport const chain =\n  <TData = unknown>(...steps: Picker<TData>[]): Picker<TData> =>\n  async (signals: Signal<TData>[]) => {\n    let current = signals;\n    for (const step of steps) {\n      current = await step(current);\n    }\n    return current;\n  };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,mBAAsB;AACtB,0BAA4B;AAQrB,MAAM,QACX,IAAqB,UACrB,OAAO,YAA6B;AAClC,MAAI,UAAU;AACd,aAAW,QAAQ,OAAO;AACxB,cAAU,MAAM,KAAK,OAAO;AAAA,EAC9B;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/pickers.d.ts

@@ -0,0 +1,21 @@
+import { type Picker } from "./types";
+/**
+ * Default picker: takes the first `count` signals in sensor order.
+ * Sort inside your sensor (or write your own picker) to prioritize differently.
+ */
+export declare const count: <TData = unknown>(count: number) => Picker<TData>;
+/**
+ * Picker: takes every signal belonging to the single busiest file — the file with
+ * the most signals this run. Focuses one run on one file so all its fixes land in a
+ * single, coherent PR. Ties are broken toward the file whose first signal appears
+ * earliest in sensor order. Signals without a `location` have no file to group by and
+ * are ignored (they can never be the busiest file).
+ */
+export declare const busiestFile: <TData = unknown>() => Picker<TData>;
+/**
+ * Runs pickers left-to-right, each narrowing the output of the previous — e.g.
+ * `chain(busiestFile(), count(3))` focuses one file, then caps it at 3 signals.
+ * Order matters: every step only sees what the one before it kept. With no steps
+ * it passes the signals through untouched.
+ */
+export declare const chain: <TData = unknown>(...steps: Picker<TData>[]) => Picker<TData>;

package/dist/pickers.js

@@ -0,0 +1,61 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var pickers_exports = {};
+__export(pickers_exports, {
+  busiestFile: () => busiestFile,
+  chain: () => chain,
+  count: () => count
+});
+module.exports = __toCommonJS(pickers_exports);
+var import_types = require("./types");
+const count = (count2) => (signals) => signals.slice(0, count2);
+const busiestFile = () => (signals) => {
+  const byFile = /* @__PURE__ */ new Map();
+  for (const signal of signals) {
+    const file = signal.location?.file;
+    if (file === void 0) continue;
+    const group = byFile.get(file);
+    if (group) {
+      group.push(signal);
+    } else {
+      byFile.set(file, [signal]);
+    }
+  }
+  let winner = [];
+  for (const group of byFile.values()) {
+    if (group.length > winner.length) {
+      winner = group;
+    }
+  }
+  return winner;
+};
+const chain = (...steps) => async (signals) => {
+  let current = signals;
+  for (const step of steps) {
+    current = await step(current);
+  }
+  return current;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  busiestFile,
+  chain,
+  count
+});
+//# sourceMappingURL=pickers.js.map

package/dist/pickers.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/pickers.ts"],
+  "sourcesContent": ["import { type Signal, type Picker } from \"./types\";\n\n/**\n * Default picker: takes the first `count` signals in sensor order.\n * Sort inside your sensor (or write your own picker) to prioritize differently.\n */\nexport const count =\n  <TData = unknown>(count: number): Picker<TData> =>\n  (signals: Signal<TData>[]) =>\n    signals.slice(0, count);\n\n/**\n * Picker: takes every signal belonging to the single busiest file \u2014 the file with\n * the most signals this run. Focuses one run on one file so all its fixes land in a\n * single, coherent PR. Ties are broken toward the file whose first signal appears\n * earliest in sensor order. Signals without a `location` have no file to group by and\n * are ignored (they can never be the busiest file).\n */\nexport const busiestFile =\n  <TData = unknown>(): Picker<TData> =>\n  (signals: Signal<TData>[]) => {\n  const byFile = new Map<string, Signal<TData>[]>();\n  for (const signal of signals) {\n    const file = signal.location?.file;\n    if (file === undefined) continue;\n    const group = byFile.get(file);\n    if (group) {\n      group.push(signal);\n    } else {\n      byFile.set(file, [signal]);\n    }\n  }\n\n  let winner: Signal<TData>[] = [];\n  for (const group of byFile.values()) {\n    if (group.length > winner.length) {\n      winner = group;\n    }\n  }\n  return winner;\n};\n\n/**\n * Runs pickers left-to-right, each narrowing the output of the previous \u2014 e.g.\n * `chain(busiestFile(), count(3))` focuses one file, then caps it at 3 signals.\n * Order matters: every step only sees what the one before it kept. With no steps\n * it passes the signals through untouched.\n */\nexport const chain =\n  <TData = unknown>(...steps: Picker<TData>[]): Picker<TData> =>\n  async (signals: Signal<TData>[]) => {\n    let current = signals;\n    for (const step of steps) {\n      current = await step(current);\n    }\n    return current;\n  };\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,mBAAyC;AAMlC,MAAM,QACX,CAAkBA,WAClB,CAAC,YACC,QAAQ,MAAM,GAAGA,MAAK;AASnB,MAAM,cACX,MACA,CAAC,YAA6B;AAC9B,QAAM,SAAS,oBAAI,IAA6B;AAChD,aAAW,UAAU,SAAS;AAC5B,UAAM,OAAO,OAAO,UAAU;AAC9B,QAAI,SAAS,OAAW;AACxB,UAAM,QAAQ,OAAO,IAAI,IAAI;AAC7B,QAAI,OAAO;AACT,YAAM,KAAK,MAAM;AAAA,IACnB,OAAO;AACL,aAAO,IAAI,MAAM,CAAC,MAAM,CAAC;AAAA,IAC3B;AAAA,EACF;AAEA,MAAI,SAA0B,CAAC;AAC/B,aAAW,SAAS,OAAO,OAAO,GAAG;AACnC,QAAI,MAAM,SAAS,OAAO,QAAQ;AAChC,eAAS;AAAA,IACX;AAAA,EACF;AACA,SAAO;AACT;AAQO,MAAM,QACX,IAAqB,UACrB,OAAO,YAA6B;AAClC,MAAI,UAAU;AACd,aAAW,QAAQ,OAAO;AACxB,cAAU,MAAM,KAAK,OAAO;AAAA,EAC9B;AACA,SAAO;AACT;",
+  "names": ["count"]
+}

package/dist/repo-handle.d.ts

@@ -0,0 +1,35 @@
+import type { Sandbox } from "@daytona/sdk";
+export interface ExecResult {
+    exitCode: number;
+    output: string;
+}
+export interface ExecOptions {
+    env?: Record<string, string>;
+    timeoutSec?: number;
+}
+export interface GrepMatch {
+    file: string;
+    line: number;
+    content: string;
+}
+/**
+ * Read-oriented view of the cloned repo inside the sandbox, handed to host-side sensors.
+ * Every method proxies to the sandbox; paths are relative to the repo root.
+ */
+export declare class RepoHandle {
+    private readonly sandbox;
+    private readonly repoPath;
+    constructor(sandbox: Sandbox, repoPath: string);
+    /** Runs a shell command with the repo root as cwd. */
+    exec(command: string, options?: ExecOptions): Promise<ExecResult>;
+    readFile(path: string): Promise<string>;
+    /** Glob for files, e.g. `glob("*.ts")`. Returned paths are relative to the repo root. */
+    glob(pattern: string): Promise<string[]>;
+    /**
+     * Search file contents, e.g. `grep("TODO:")`. File paths are relative to the repo
+     * root. Pass `paths` to restrict the search to those folders (also repo-relative).
+     */
+    grep(pattern: string, paths?: string[]): Promise<GrepMatch[]>;
+    private resolve;
+    private relative;
+}

package/dist/repo-handle.js

@@ -0,0 +1,75 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var repo_handle_exports = {};
+__export(repo_handle_exports, {
+  RepoHandle: () => RepoHandle
+});
+module.exports = __toCommonJS(repo_handle_exports);
+class RepoHandle {
+  constructor(sandbox, repoPath) {
+    this.sandbox = sandbox;
+    this.repoPath = repoPath;
+  }
+  /** Runs a shell command with the repo root as cwd. */
+  async exec(command, options) {
+    const response = await this.sandbox.process.executeCommand(
+      command,
+      this.repoPath,
+      options?.env,
+      options?.timeoutSec ?? 300
+    );
+    return { exitCode: response.exitCode, output: response.result };
+  }
+  async readFile(path) {
+    const buffer = await this.sandbox.fs.downloadFile(`${this.repoPath}/${path}`);
+    return buffer.toString("utf-8");
+  }
+  /** Glob for files, e.g. `glob("*.ts")`. Returned paths are relative to the repo root. */
+  async glob(pattern) {
+    const response = await this.sandbox.fs.searchFiles(this.repoPath, pattern);
+    return response.files.map((file) => this.relative(file));
+  }
+  /**
+   * Search file contents, e.g. `grep("TODO:")`. File paths are relative to the repo
+   * root. Pass `paths` to restrict the search to those folders (also repo-relative).
+   */
+  async grep(pattern, paths) {
+    const roots = paths?.length ? paths : ["."];
+    const results = await Promise.all(roots.map((root) => this.sandbox.fs.findFiles(this.resolve(root), pattern)));
+    return results.flat().map((match) => ({
+      file: this.relative(match.file),
+      line: match.line,
+      content: match.content
+    }));
+  }
+  resolve(path) {
+    const trimmed = path.replace(/^\.\/?/, "").replace(/\/+$/, "");
+    return trimmed === "" ? this.repoPath : `${this.repoPath}/${trimmed}`;
+  }
+  relative(file) {
+    const marker = `${this.repoPath}/`;
+    const index = file.indexOf(marker);
+    return index === -1 ? file : file.slice(index + marker.length);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RepoHandle
+});
+//# sourceMappingURL=repo-handle.js.map

package/dist/repo-handle.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/repo-handle.ts"],
+  "sourcesContent": ["import type { Sandbox } from \"@daytona/sdk\";\n\nexport interface ExecResult {\n  exitCode: number;\n  output: string;\n}\n\nexport interface ExecOptions {\n  env?: Record<string, string>;\n  timeoutSec?: number;\n}\n\nexport interface GrepMatch {\n  file: string;\n  line: number;\n  content: string;\n}\n\n/**\n * Read-oriented view of the cloned repo inside the sandbox, handed to host-side sensors.\n * Every method proxies to the sandbox; paths are relative to the repo root.\n */\nexport class RepoHandle {\n  constructor(\n    private readonly sandbox: Sandbox,\n    private readonly repoPath: string,\n  ) {}\n\n  /** Runs a shell command with the repo root as cwd. */\n  async exec(command: string, options?: ExecOptions): Promise<ExecResult> {\n    const response = await this.sandbox.process.executeCommand(\n      command,\n      this.repoPath,\n      options?.env,\n      options?.timeoutSec ?? 300,\n    );\n    return { exitCode: response.exitCode, output: response.result };\n  }\n\n  async readFile(path: string): Promise<string> {\n    const buffer = await this.sandbox.fs.downloadFile(`${this.repoPath}/${path}`);\n    return buffer.toString(\"utf-8\");\n  }\n\n  /** Glob for files, e.g. `glob(\"*.ts\")`. Returned paths are relative to the repo root. */\n  async glob(pattern: string): Promise<string[]> {\n    const response = await this.sandbox.fs.searchFiles(this.repoPath, pattern);\n    return response.files.map((file) => this.relative(file));\n  }\n\n  /**\n   * Search file contents, e.g. `grep(\"TODO:\")`. File paths are relative to the repo\n   * root. Pass `paths` to restrict the search to those folders (also repo-relative).\n   */\n  async grep(pattern: string, paths?: string[]): Promise<GrepMatch[]> {\n    const roots = paths?.length ? paths : [\".\"];\n    const results = await Promise.all(roots.map((root) => this.sandbox.fs.findFiles(this.resolve(root), pattern)));\n    return results.flat().map((match) => ({\n      file: this.relative(match.file),\n      line: match.line,\n      content: match.content,\n    }));\n  }\n\n  private resolve(path: string): string {\n    const trimmed = path.replace(/^\\.\\/?/, \"\").replace(/\\/+$/, \"\");\n    return trimmed === \"\" ? this.repoPath : `${this.repoPath}/${trimmed}`;\n  }\n\n  private relative(file: string): string {\n    const marker = `${this.repoPath}/`;\n    const index = file.indexOf(marker);\n    return index === -1 ? file : file.slice(index + marker.length);\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAsBO,MAAM,WAAW;AAAA,EACtB,YACmB,SACA,UACjB;AAFiB;AACA;AAAA,EAChB;AAAA;AAAA,EAGH,MAAM,KAAK,SAAiB,SAA4C;AACtE,UAAM,WAAW,MAAM,KAAK,QAAQ,QAAQ;AAAA,MAC1C;AAAA,MACA,KAAK;AAAA,MACL,SAAS;AAAA,MACT,SAAS,cAAc;AAAA,IACzB;AACA,WAAO,EAAE,UAAU,SAAS,UAAU,QAAQ,SAAS,OAAO;AAAA,EAChE;AAAA,EAEA,MAAM,SAAS,MAA+B;AAC5C,UAAM,SAAS,MAAM,KAAK,QAAQ,GAAG,aAAa,GAAG,KAAK,QAAQ,IAAI,IAAI,EAAE;AAC5E,WAAO,OAAO,SAAS,OAAO;AAAA,EAChC;AAAA;AAAA,EAGA,MAAM,KAAK,SAAoC;AAC7C,UAAM,WAAW,MAAM,KAAK,QAAQ,GAAG,YAAY,KAAK,UAAU,OAAO;AACzE,WAAO,SAAS,MAAM,IAAI,CAAC,SAAS,KAAK,SAAS,IAAI,CAAC;AAAA,EACzD;AAAA;AAAA;AAAA;AAAA;AAAA,EAMA,MAAM,KAAK,SAAiB,OAAwC;AAClE,UAAM,QAAQ,OAAO,SAAS,QAAQ,CAAC,GAAG;AAC1C,UAAM,UAAU,MAAM,QAAQ,IAAI,MAAM,IAAI,CAAC,SAAS,KAAK,QAAQ,GAAG,UAAU,KAAK,QAAQ,IAAI,GAAG,OAAO,CAAC,CAAC;AAC7G,WAAO,QAAQ,KAAK,EAAE,IAAI,CAAC,WAAW;AAAA,MACpC,MAAM,KAAK,SAAS,MAAM,IAAI;AAAA,MAC9B,MAAM,MAAM;AAAA,MACZ,SAAS,MAAM;AAAA,IACjB,EAAE;AAAA,EACJ;AAAA,EAEQ,QAAQ,MAAsB;AACpC,UAAM,UAAU,KAAK,QAAQ,UAAU,EAAE,EAAE,QAAQ,QAAQ,EAAE;AAC7D,WAAO,YAAY,KAAK,KAAK,WAAW,GAAG,KAAK,QAAQ,IAAI,OAAO;AAAA,EACrE;AAAA,EAEQ,SAAS,MAAsB;AACrC,UAAM,SAAS,GAAG,KAAK,QAAQ;AAC/B,UAAM,QAAQ,KAAK,QAAQ,MAAM;AACjC,WAAO,UAAU,KAAK,OAAO,KAAK,MAAM,QAAQ,OAAO,MAAM;AAAA,EAC/D;AACF;",
+  "names": []
+}

package/dist/sandbox.d.ts

@@ -0,0 +1,33 @@
+import type { AgentContext } from "./agents";
+import type { PrComment } from "./github";
+import type { ControlLoopConfig } from "./types";
+import type { RunLog } from "./log";
+/** Where every entry point clones the repo inside the sandbox. */
+export declare const REPO_PATH = "workspace/repo";
+/** Per-run bookkeeping dir (prompts, sensor scripts); never committed to a PR. */
+export declare const SCRATCH_DIR = ".control-loop";
+/**
+ * Stages and commits everything with the real git binary. Daytona's toolbox git (go-git)
+ * 500s on pathological filenames an agent can leave behind (e.g. a file named `\`);
+ * real git handles them.
+ *
+ * `--no-verify` skips repo git hooks: they target interactive developers (a check-only
+ * hook like `oxfmt --check` can never be satisfied by a bot that doesn't know the fix
+ * command), and the PR's CI is the authoritative gate for the loop's changes. Repo
+ * conventions are applied through `config.hooks.preCommit` instead.
+ */
+export declare function commitAll(ctx: AgentContext, message: string): Promise<void>;
+/**
+ * Runs one of the configured lifecycle hooks (`config.hooks`) from the repo root,
+ * as a logged step. A missing hook is a no-op; a non-zero exit aborts the run.
+ */
+export declare function runConfiguredCommand(name: keyof NonNullable<ControlLoopConfig["hooks"]>, config: ControlLoopConfig, ctx: AgentContext, log: RunLog): Promise<void>;
+/**
+ * The loop's memory lives in the repo itself, so it ships with the PR that recorded it
+ * and is available to every future clone once merged.
+ */
+export declare function memoryPath(label: string): string;
+export declare function readMemory(ctx: AgentContext, label: string): Promise<string | undefined>;
+export declare function appendMemory(ctx: AgentContext, label: string, existing: string | undefined, feedback: PrComment[]): Promise<void>;
+/** Appended to the agent's instructions whenever the loop has accumulated memory. */
+export declare function memoryNote(memory: string | undefined): string;

package/dist/sandbox.js

@@ -0,0 +1,91 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var sandbox_exports = {};
+__export(sandbox_exports, {
+  REPO_PATH: () => REPO_PATH,
+  SCRATCH_DIR: () => SCRATCH_DIR,
+  appendMemory: () => appendMemory,
+  commitAll: () => commitAll,
+  memoryNote: () => memoryNote,
+  memoryPath: () => memoryPath,
+  readMemory: () => readMemory,
+  runConfiguredCommand: () => runConfiguredCommand
+});
+module.exports = __toCommonJS(sandbox_exports);
+const REPO_PATH = "workspace/repo";
+const SCRATCH_DIR = ".control-loop";
+async function commitAll(ctx, message) {
+  const add = await ctx.exec("git add -A");
+  if (add.exitCode !== 0) throw new Error(`git add failed: ${add.output}`);
+  const commit = await ctx.exec(`git commit --no-verify -m ${shellQuote(message)}`);
+  if (commit.exitCode !== 0) throw new Error(`git commit failed: ${commit.output}`);
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function runConfiguredCommand(name, config, ctx, log) {
+  const command = config.hooks?.[name];
+  if (!command) return;
+  await log.step(`running ${name} \`${command}\``, async () => {
+    const result = await ctx.exec(command, { timeoutSec: 900 });
+    if (result.exitCode !== 0) {
+      throw new Error(`${name} command "${command}" exited ${result.exitCode}: ${result.output}`);
+    }
+  });
+}
+function memoryPath(label) {
+  return `.github/control-loop/memory-${label}.md`;
+}
+async function readMemory(ctx, label) {
+  const result = await ctx.exec(`cat ${memoryPath(label)}`);
+  return result.exitCode === 0 ? result.output : void 0;
+}
+async function appendMemory(ctx, label, existing, feedback) {
+  const header = `# Control loop memory \u2014 ${label}
+
+Improvements collected from \`/feedback\` PR comments. Every entry is included in the agent's instructions on all future runs of this loop.
+`;
+  const entries = feedback.map(
+    (comment) => `- ${comment.createdAt.slice(0, 10)} @${comment.author}: ${comment.body.trim()}`
+  );
+  const content = `${(existing ?? header).trimEnd()}
+${entries.join("\n")}
+`;
+  await ctx.exec(`mkdir -p ${memoryPath(label).split("/").slice(0, -1).join("/")}`);
+  await ctx.writeFile(memoryPath(label), content);
+}
+function memoryNote(memory) {
+  if (!memory) return "";
+  return `
+
+Control loop memory \u2014 standing guidance accumulated from human feedback on past PRs. Follow it:
+${memory}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  REPO_PATH,
+  SCRATCH_DIR,
+  appendMemory,
+  commitAll,
+  memoryNote,
+  memoryPath,
+  readMemory,
+  runConfiguredCommand
+});
+//# sourceMappingURL=sandbox.js.map

package/dist/sandbox.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/sandbox.ts"],
+  "sourcesContent": ["import type { AgentContext } from \"./agents\";\nimport type { PrComment } from \"./github\";\nimport type { ControlLoopConfig } from \"./types\";\nimport type { RunLog } from \"./log\";\n\n/** Where every entry point clones the repo inside the sandbox. */\nexport const REPO_PATH = \"workspace/repo\";\n/** Per-run bookkeeping dir (prompts, sensor scripts); never committed to a PR. */\nexport const SCRATCH_DIR = \".control-loop\";\n\n/**\n * Stages and commits everything with the real git binary. Daytona's toolbox git (go-git)\n * 500s on pathological filenames an agent can leave behind (e.g. a file named `\\`);\n * real git handles them.\n *\n * `--no-verify` skips repo git hooks: they target interactive developers (a check-only\n * hook like `oxfmt --check` can never be satisfied by a bot that doesn't know the fix\n * command), and the PR's CI is the authoritative gate for the loop's changes. Repo\n * conventions are applied through `config.hooks.preCommit` instead.\n */\nexport async function commitAll(ctx: AgentContext, message: string): Promise<void> {\n  const add = await ctx.exec(\"git add -A\");\n  if (add.exitCode !== 0) throw new Error(`git add failed: ${add.output}`);\n  const commit = await ctx.exec(`git commit --no-verify -m ${shellQuote(message)}`);\n  if (commit.exitCode !== 0) throw new Error(`git commit failed: ${commit.output}`);\n}\n\n/** Single-quote for the shell; commit messages carry arbitrary sensor/signal text. */\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, `'\\\\''`)}'`;\n}\n\n/**\n * Runs one of the configured lifecycle hooks (`config.hooks`) from the repo root,\n * as a logged step. A missing hook is a no-op; a non-zero exit aborts the run.\n */\nexport async function runConfiguredCommand(\n  name: keyof NonNullable<ControlLoopConfig[\"hooks\"]>,\n  config: ControlLoopConfig,\n  ctx: AgentContext,\n  log: RunLog,\n): Promise<void> {\n  const command = config.hooks?.[name];\n  if (!command) return;\n  await log.step(`running ${name} \\`${command}\\``, async () => {\n    const result = await ctx.exec(command, { timeoutSec: 900 });\n    if (result.exitCode !== 0) {\n      throw new Error(`${name} command \"${command}\" exited ${result.exitCode}: ${result.output}`);\n    }\n  });\n}\n\n/**\n * The loop's memory lives in the repo itself, so it ships with the PR that recorded it\n * and is available to every future clone once merged.\n */\nexport function memoryPath(label: string): string {\n  return `.github/control-loop/memory-${label}.md`;\n}\n\nexport async function readMemory(ctx: AgentContext, label: string): Promise<string | undefined> {\n  const result = await ctx.exec(`cat ${memoryPath(label)}`);\n  return result.exitCode === 0 ? result.output : undefined;\n}\n\nexport async function appendMemory(\n  ctx: AgentContext,\n  label: string,\n  existing: string | undefined,\n  feedback: PrComment[],\n): Promise<void> {\n  const header =\n    `# Control loop memory \u2014 ${label}\\n\\n` +\n    \"Improvements collected from `/feedback` PR comments. \" +\n    \"Every entry is included in the agent's instructions on all future runs of this loop.\\n\";\n  const entries = feedback.map(\n    (comment) => `- ${comment.createdAt.slice(0, 10)} @${comment.author}: ${comment.body.trim()}`,\n  );\n  const content = `${(existing ?? header).trimEnd()}\\n${entries.join(\"\\n\")}\\n`;\n  await ctx.exec(`mkdir -p ${memoryPath(label).split(\"/\").slice(0, -1).join(\"/\")}`);\n  await ctx.writeFile(memoryPath(label), content);\n}\n\n/** Appended to the agent's instructions whenever the loop has accumulated memory. */\nexport function memoryNote(memory: string | undefined): string {\n  if (!memory) return \"\";\n  return `\\n\\nControl loop memory \u2014 standing guidance accumulated from human feedback on past PRs. Follow it:\\n${memory}`;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMO,MAAM,YAAY;AAElB,MAAM,cAAc;AAY3B,eAAsB,UAAU,KAAmB,SAAgC;AACjF,QAAM,MAAM,MAAM,IAAI,KAAK,YAAY;AACvC,MAAI,IAAI,aAAa,EAAG,OAAM,IAAI,MAAM,mBAAmB,IAAI,MAAM,EAAE;AACvE,QAAM,SAAS,MAAM,IAAI,KAAK,6BAA6B,WAAW,OAAO,CAAC,EAAE;AAChF,MAAI,OAAO,aAAa,EAAG,OAAM,IAAI,MAAM,sBAAsB,OAAO,MAAM,EAAE;AAClF;AAGA,SAAS,WAAW,OAAuB;AACzC,SAAO,IAAI,MAAM,QAAQ,MAAM,OAAO,CAAC;AACzC;AAMA,eAAsB,qBACpB,MACA,QACA,KACA,KACe;AACf,QAAM,UAAU,OAAO,QAAQ,IAAI;AACnC,MAAI,CAAC,QAAS;AACd,QAAM,IAAI,KAAK,WAAW,IAAI,MAAM,OAAO,MAAM,YAAY;AAC3D,UAAM,SAAS,MAAM,IAAI,KAAK,SAAS,EAAE,YAAY,IAAI,CAAC;AAC1D,QAAI,OAAO,aAAa,GAAG;AACzB,YAAM,IAAI,MAAM,GAAG,IAAI,aAAa,OAAO,YAAY,OAAO,QAAQ,KAAK,OAAO,MAAM,EAAE;AAAA,IAC5F;AAAA,EACF,CAAC;AACH;AAMO,SAAS,WAAW,OAAuB;AAChD,SAAO,+BAA+B,KAAK;AAC7C;AAEA,eAAsB,WAAW,KAAmB,OAA4C;AAC9F,QAAM,SAAS,MAAM,IAAI,KAAK,OAAO,WAAW,KAAK,CAAC,EAAE;AACxD,SAAO,OAAO,aAAa,IAAI,OAAO,SAAS;AACjD;AAEA,eAAsB,aACpB,KACA,OACA,UACA,UACe;AACf,QAAM,SACJ,gCAA2B,KAAK;AAAA;AAAA;AAAA;AAGlC,QAAM,UAAU,SAAS;AAAA,IACvB,CAAC,YAAY,KAAK,QAAQ,UAAU,MAAM,GAAG,EAAE,CAAC,KAAK,QAAQ,MAAM,KAAK,QAAQ,KAAK,KAAK,CAAC;AAAA,EAC7F;AACA,QAAM,UAAU,IAAI,YAAY,QAAQ,QAAQ,CAAC;AAAA,EAAK,QAAQ,KAAK,IAAI,CAAC;AAAA;AACxE,QAAM,IAAI,KAAK,YAAY,WAAW,KAAK,EAAE,MAAM,GAAG,EAAE,MAAM,GAAG,EAAE,EAAE,KAAK,GAAG,CAAC,EAAE;AAChF,QAAM,IAAI,UAAU,WAAW,KAAK,GAAG,OAAO;AAChD;AAGO,SAAS,WAAW,QAAoC;AAC7D,MAAI,CAAC,OAAQ,QAAO;AACpB,SAAO;AAAA;AAAA;AAAA,EAAwG,MAAM;AACvH;",
+  "names": []
+}

package/dist/sensors/ast-grep.d.ts

@@ -0,0 +1,41 @@
+import type { SignalPriority } from "../types";
+import type { SensorFn } from "./index";
+export interface AstGrepMatch {
+    file: string;
+    /** 1-based, like Signal.location.line. */
+    line: number;
+    /** Source text of the matched node. */
+    text: string;
+}
+export interface AstGrepOptions {
+    /** ast-grep pattern, e.g. "console.log($$$ARGS)". */
+    pattern: string;
+    /** Language to parse, e.g. "typescript" or "tsx". Omit to let ast-grep infer it per file. */
+    language?: string;
+    /** Applied to every signal. Default "medium". */
+    priority?: SignalPriority;
+    /**
+     * Builds the signal message for a match. Signals are matched across runs by
+     * file + message, so keep it stable for a given anomaly. The default includes the
+     * matched text, which naturally disappears once the anomaly is fixed.
+     */
+    message?: (match: AstGrepMatch) => string;
+    /**
+     * Paths (relative to the repo root) to scan. Required — scoping the scan keeps the
+     * signal set intentional; pass ["."] to explicitly scan the whole repo.
+     */
+    paths: string[];
+}
+/**
+ * Sensor that runs [ast-grep](https://ast-grep.github.io) inside the sandbox and turns
+ * every structural match into a signal. The CLI is installed on first use if the
+ * sandbox image doesn't have it (pre-bake `@ast-grep/cli` in a snapshot to skip that).
+ *
+ * @example
+ * sensor: sensors.astGrep({
+ *   pattern: "throw new Error($$$)",
+ *   language: "ts",
+ *   paths: ["packages/backend/src/trpc/routers/"],
+ * })
+ */
+export declare const astGrep: (options: AstGrepOptions) => SensorFn<AstGrepMatch>;

package/dist/sensors/ast-grep.js

@@ -0,0 +1,65 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ast_grep_exports = {};
+__export(ast_grep_exports, {
+  astGrep: () => astGrep
+});
+module.exports = __toCommonJS(ast_grep_exports);
+const astGrep = (options) => {
+  return async (repo) => {
+    const install = await repo.exec("command -v ast-grep || npm install -g @ast-grep/cli", { timeoutSec: 600 });
+    if (install.exitCode !== 0) {
+      throw new Error(`failed to install ast-grep: ${install.output}`);
+    }
+    const lang = options.language ? ` --lang ${options.language}` : "";
+    const paths = ` ${options.paths.map(shellQuote).join(" ")}`;
+    const run = await repo.exec(`ast-grep run --pattern ${shellQuote(options.pattern)}${lang} --json${paths}`, {
+      timeoutSec: 600
+    });
+    if (run.exitCode !== 0) {
+      throw new Error(`ast-grep exited ${run.exitCode}: ${run.output}`);
+    }
+    const results = JSON.parse(run.output);
+    return results.map((result) => {
+      const match = {
+        file: result.file,
+        line: result.range.start.line + 1,
+        text: result.text
+      };
+      return {
+        location: { file: match.file, line: match.line },
+        message: options.message?.(match) ?? defaultMessage(options.pattern, match),
+        priority: options.priority ?? "medium",
+        data: match
+      };
+    });
+  };
+};
+function defaultMessage(pattern, match) {
+  const text = match.text.split("\n")[0].slice(0, 120);
+  return `matches pattern "${pattern}": ${text}`;
+}
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  astGrep
+});
+//# sourceMappingURL=ast-grep.js.map

package/dist/sensors/ast-grep.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/sensors/ast-grep.ts"],
+  "sourcesContent": ["import type { SignalPriority } from \"../types\";\nimport type { SensorFn } from \"./index\";\n\nexport interface AstGrepMatch {\n  file: string;\n  /** 1-based, like Signal.location.line. */\n  line: number;\n  /** Source text of the matched node. */\n  text: string;\n}\n\nexport interface AstGrepOptions {\n  /** ast-grep pattern, e.g. \"console.log($$$ARGS)\". */\n  pattern: string;\n  /** Language to parse, e.g. \"typescript\" or \"tsx\". Omit to let ast-grep infer it per file. */\n  language?: string;\n  /** Applied to every signal. Default \"medium\". */\n  priority?: SignalPriority;\n  /**\n   * Builds the signal message for a match. Signals are matched across runs by\n   * file + message, so keep it stable for a given anomaly. The default includes the\n   * matched text, which naturally disappears once the anomaly is fixed.\n   */\n  message?: (match: AstGrepMatch) => string;\n  /**\n   * Paths (relative to the repo root) to scan. Required \u2014 scoping the scan keeps the\n   * signal set intentional; pass [\".\"] to explicitly scan the whole repo.\n   */\n  paths: string[];\n}\n\n/**\n * Sensor that runs [ast-grep](https://ast-grep.github.io) inside the sandbox and turns\n * every structural match into a signal. The CLI is installed on first use if the\n * sandbox image doesn't have it (pre-bake `@ast-grep/cli` in a snapshot to skip that).\n *\n * @example\n * sensor: sensors.astGrep({\n *   pattern: \"throw new Error($$$)\",\n *   language: \"ts\",\n *   paths: [\"packages/backend/src/trpc/routers/\"],\n * })\n */\nexport const astGrep = (options: AstGrepOptions): SensorFn<AstGrepMatch> => {\n  return async (repo) => {\n    const install = await repo.exec(\"command -v ast-grep || npm install -g @ast-grep/cli\", { timeoutSec: 600 });\n    if (install.exitCode !== 0) {\n      throw new Error(`failed to install ast-grep: ${install.output}`);\n    }\n\n    const lang = options.language ? ` --lang ${options.language}` : \"\";\n    const paths = ` ${options.paths.map(shellQuote).join(\" \")}`;\n    const run = await repo.exec(`ast-grep run --pattern ${shellQuote(options.pattern)}${lang} --json${paths}`, {\n      timeoutSec: 600,\n    });\n    if (run.exitCode !== 0) {\n      throw new Error(`ast-grep exited ${run.exitCode}: ${run.output}`);\n    }\n\n    const results = JSON.parse(run.output) as Array<{\n      file: string;\n      text: string;\n      range: { start: { line: number } };\n    }>;\n\n    return results.map((result) => {\n      const match: AstGrepMatch = {\n        file: result.file,\n        line: result.range.start.line + 1,\n        text: result.text,\n      };\n      return {\n        location: { file: match.file, line: match.line },\n        message: options.message?.(match) ?? defaultMessage(options.pattern, match),\n        priority: options.priority ?? \"medium\",\n        data: match,\n      };\n    });\n  };\n};\n\nfunction defaultMessage(pattern: string, match: AstGrepMatch): string {\n  const text = match.text.split(\"\\n\")[0]!.slice(0, 120);\n  return `matches pattern \"${pattern}\": ${text}`;\n}\n\n/** Single-quote for the shell \u2014 ast-grep patterns are full of `$VAR`s the shell must not expand. */\nfunction shellQuote(value: string): string {\n  return `'${value.replace(/'/g, `'\\\\''`)}'`;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AA2CO,MAAM,UAAU,CAAC,YAAoD;AAC1E,SAAO,OAAO,SAAS;AACrB,UAAM,UAAU,MAAM,KAAK,KAAK,uDAAuD,EAAE,YAAY,IAAI,CAAC;AAC1G,QAAI,QAAQ,aAAa,GAAG;AAC1B,YAAM,IAAI,MAAM,+BAA+B,QAAQ,MAAM,EAAE;AAAA,IACjE;AAEA,UAAM,OAAO,QAAQ,WAAW,WAAW,QAAQ,QAAQ,KAAK;AAChE,UAAM,QAAQ,IAAI,QAAQ,MAAM,IAAI,UAAU,EAAE,KAAK,GAAG,CAAC;AACzD,UAAM,MAAM,MAAM,KAAK,KAAK,0BAA0B,WAAW,QAAQ,OAAO,CAAC,GAAG,IAAI,UAAU,KAAK,IAAI;AAAA,MACzG,YAAY;AAAA,IACd,CAAC;AACD,QAAI,IAAI,aAAa,GAAG;AACtB,YAAM,IAAI,MAAM,mBAAmB,IAAI,QAAQ,KAAK,IAAI,MAAM,EAAE;AAAA,IAClE;AAEA,UAAM,UAAU,KAAK,MAAM,IAAI,MAAM;AAMrC,WAAO,QAAQ,IAAI,CAAC,WAAW;AAC7B,YAAM,QAAsB;AAAA,QAC1B,MAAM,OAAO;AAAA,QACb,MAAM,OAAO,MAAM,MAAM,OAAO;AAAA,QAChC,MAAM,OAAO;AAAA,MACf;AACA,aAAO;AAAA,QACL,UAAU,EAAE,MAAM,MAAM,MAAM,MAAM,MAAM,KAAK;AAAA,QAC/C,SAAS,QAAQ,UAAU,KAAK,KAAK,eAAe,QAAQ,SAAS,KAAK;AAAA,QAC1E,UAAU,QAAQ,YAAY;AAAA,QAC9B,MAAM;AAAA,MACR;AAAA,IACF,CAAC;AAAA,EACH;AACF;AAEA,SAAS,eAAe,SAAiB,OAA6B;AACpE,QAAM,OAAO,MAAM,KAAK,MAAM,IAAI,EAAE,CAAC,EAAG,MAAM,GAAG,GAAG;AACpD,SAAO,oBAAoB,OAAO,MAAM,IAAI;AAC9C;AAGA,SAAS,WAAW,OAAuB;AACzC,SAAO,IAAI,MAAM,QAAQ,MAAM,OAAO,CAAC;AACzC;",
+  "names": []
+}

package/dist/sensors/grep.d.ts

@@ -0,0 +1,31 @@
+import type { GrepMatch } from "../repo-handle";
+import type { SignalPriority } from "../types";
+import type { SensorFn } from "./index";
+export interface GrepOptions {
+    /** Text/regex pattern searched in file contents. */
+    pattern: string;
+    /**
+     * Paths (relative to the repo root) to search. Required — scoping the search keeps
+     * the signal set intentional; pass ["."] to explicitly search the whole repo.
+     */
+    paths: string[];
+    /** Applied to every signal. Default "medium". */
+    priority?: SignalPriority;
+    /**
+     * Builds the signal message for a match. Signals are matched across runs by
+     * file + message, so keep it stable for a given anomaly. The default includes the
+     * matched line, which naturally disappears once the anomaly is fixed.
+     */
+    message?: (match: GrepMatch) => string;
+}
+/**
+ * Sensor that searches file contents and turns every matching line into a signal.
+ *
+ * @example
+ * sensor: sensors.grep({
+ *   pattern: "TODO:",
+ *   paths: ["src/"],
+ *   message: (match) => `unresolved TODO: ${match.content.trim()}`,
+ * })
+ */
+export declare const grep: (options: GrepOptions) => SensorFn<GrepMatch>;

package/dist/sensors/grep.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var grep_exports = {};
+__export(grep_exports, {
+  grep: () => grep
+});
+module.exports = __toCommonJS(grep_exports);
+const grep = (options) => {
+  return async (repo) => {
+    const matches = await repo.grep(options.pattern, options.paths);
+    return matches.map((match) => ({
+      location: { file: match.file, line: match.line },
+      message: options.message?.(match) ?? `matches "${options.pattern}": ${match.content.trim().slice(0, 120)}`,
+      priority: options.priority ?? "medium",
+      data: match
+    }));
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  grep
+});
+//# sourceMappingURL=grep.js.map

package/dist/sensors/grep.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/sensors/grep.ts"],
+  "sourcesContent": ["import type { GrepMatch } from \"../repo-handle\";\nimport type { SignalPriority } from \"../types\";\nimport type { SensorFn } from \"./index\";\n\nexport interface GrepOptions {\n  /** Text/regex pattern searched in file contents. */\n  pattern: string;\n  /**\n   * Paths (relative to the repo root) to search. Required \u2014 scoping the search keeps\n   * the signal set intentional; pass [\".\"] to explicitly search the whole repo.\n   */\n  paths: string[];\n  /** Applied to every signal. Default \"medium\". */\n  priority?: SignalPriority;\n  /**\n   * Builds the signal message for a match. Signals are matched across runs by\n   * file + message, so keep it stable for a given anomaly. The default includes the\n   * matched line, which naturally disappears once the anomaly is fixed.\n   */\n  message?: (match: GrepMatch) => string;\n}\n\n/**\n * Sensor that searches file contents and turns every matching line into a signal.\n *\n * @example\n * sensor: sensors.grep({\n *   pattern: \"TODO:\",\n *   paths: [\"src/\"],\n *   message: (match) => `unresolved TODO: ${match.content.trim()}`,\n * })\n */\nexport const grep = (options: GrepOptions): SensorFn<GrepMatch> => {\n  return async (repo) => {\n    const matches = await repo.grep(options.pattern, options.paths);\n    return matches.map((match) => ({\n      location: { file: match.file, line: match.line },\n      message: options.message?.(match) ?? `matches \"${options.pattern}\": ${match.content.trim().slice(0, 120)}`,\n      priority: options.priority ?? \"medium\",\n      data: match,\n    }));\n  };\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAgCO,MAAM,OAAO,CAAC,YAA8C;AACjE,SAAO,OAAO,SAAS;AACrB,UAAM,UAAU,MAAM,KAAK,KAAK,QAAQ,SAAS,QAAQ,KAAK;AAC9D,WAAO,QAAQ,IAAI,CAAC,WAAW;AAAA,MAC7B,UAAU,EAAE,MAAM,MAAM,MAAM,MAAM,MAAM,KAAK;AAAA,MAC/C,SAAS,QAAQ,UAAU,KAAK,KAAK,YAAY,QAAQ,OAAO,MAAM,MAAM,QAAQ,KAAK,EAAE,MAAM,GAAG,GAAG,CAAC;AAAA,MACxG,UAAU,QAAQ,YAAY;AAAA,MAC9B,MAAM;AAAA,IACR,EAAE;AAAA,EACJ;AACF;",
+  "names": []
+}