open-agents-ai 0.187.431 → 0.187.433

package/dist/index.js

@@ -355,105 +355,6 @@ var init_typed_node_events = __esm({
   }
 });
 
-// packages/cli/src/ui/spinner.ts
-var FRAMES, INTERVAL_MS, Spinner;
-var init_spinner = __esm({
-  "packages/cli/src/ui/spinner.ts"() {
-    "use strict";
-    FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
-    INTERVAL_MS = 80;
-    Spinner = class {
-      _text;
-      _frameIndex = 0;
-      _timer = null;
-      _isSpinning = false;
-      constructor(text) {
-        this._text = text;
-      }
-      // --------------------------------------------------------------------------
-      // Public API
-      // --------------------------------------------------------------------------
-      get text() {
-        return this._text;
-      }
-      set text(value2) {
-        this._text = value2;
-        if (this._isSpinning && process.stdout.isTTY) {
-          this._render();
-        }
-      }
-      get isSpinning() {
-        return this._isSpinning;
-      }
-      start() {
-        if (this._isSpinning) return this;
-        this._isSpinning = true;
-        this._frameIndex = 0;
-        if (process.stdout.isTTY) {
-          process.stdout.write("\x1B[?25l");
-          this._render();
-          this._timer = setInterval(() => {
-            this._frameIndex = (this._frameIndex + 1) % FRAMES.length;
-            this._render();
-          }, INTERVAL_MS);
-        } else {
-          process.stdout.write(`${this._text}
-`);
-        }
-        return this;
-      }
-      stop() {
-        if (!this._isSpinning) return this;
-        this._isSpinning = false;
-        if (this._timer !== null) {
-          clearInterval(this._timer);
-          this._timer = null;
-        }
-        if (process.stdout.isTTY) {
-          process.stdout.write("\r\x1B[K");
-          process.stdout.write("\x1B[?25h");
-        }
-        return this;
-      }
-      succeed(message2) {
-        this.stop();
-        const msg = message2 ?? this._text;
-        process.stdout.write(`\x1B[32m✔\x1B[0m ${msg}
-`);
-        return this;
-      }
-      fail(message2) {
-        this.stop();
-        const msg = message2 ?? this._text;
-        process.stdout.write(`\x1B[31m✖\x1B[0m ${msg}
-`);
-        return this;
-      }
-      warn(message2) {
-        this.stop();
-        const msg = message2 ?? this._text;
-        process.stdout.write(`\x1B[33m⚠\x1B[0m ${msg}
-`);
-        return this;
-      }
-      info(message2) {
-        this.stop();
-        const msg = message2 ?? this._text;
-        process.stdout.write(`\x1B[36mℹ\x1B[0m ${msg}
-`);
-        return this;
-      }
-      // --------------------------------------------------------------------------
-      // Private
-      // --------------------------------------------------------------------------
-      _render() {
-        const frame = FRAMES[this._frameIndex] ?? FRAMES[0];
-        process.stdout.write(`\r\x1B[36m${frame}\x1B[0m ${this._text}`);
-      }
-    };
-  }
-});
-
 // packages/backend-vllm/dist/sleep.js
 var SleepManager;
 var init_sleep = __esm({
@@ -88633,7 +88534,7 @@ var require_auto = __commonJS({
 // ../../../node_modules/acme-client/src/client.js
 var require_client = __commonJS({
   "../../../node_modules/acme-client/src/client.js"(exports, module) {
-    var { createHash: createHash13 } = __require("crypto");
+    var { createHash: createHash14 } = __require("crypto");
     var { getPemBodyAsB64u } = require_crypto();
     var { log: log22 } = require_logger();
     var HttpClient = require_http();
@@ -88944,14 +88845,14 @@ var require_client = __commonJS({
        */
       async getChallengeKeyAuthorization(challenge) {
         const jwk = this.http.getJwk();
-        const keysum = createHash13("sha256").update(JSON.stringify(jwk));
+        const keysum = createHash14("sha256").update(JSON.stringify(jwk));
         const thumbprint = keysum.digest("base64url");
         const result = `${challenge.token}.${thumbprint}`;
         if (challenge.type === "http-01") {
           return result;
         }
         if (challenge.type === "dns-01") {
-          return createHash13("sha256").update(result).digest("base64url");
+          return createHash14("sha256").update(result).digest("base64url");
         }
         if (challenge.type === "tls-alpn-01") {
           return result;
@@ -231549,7 +231450,7 @@ var require_websocket2 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes23, createHash: createHash13 } = __require("crypto");
+    var { randomBytes: randomBytes23, createHash: createHash14 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate2();
@@ -232209,7 +232110,7 @@ var require_websocket2 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash13("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash14("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -232576,7 +232477,7 @@ var require_websocket_server = __commonJS({
     var EventEmitter12 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash13 } = __require("crypto");
+    var { createHash: createHash14 } = __require("crypto");
     var extension2 = require_extension2();
     var PerMessageDeflate2 = require_permessage_deflate2();
     var subprotocol2 = require_subprotocol();
@@ -232877,7 +232778,7 @@ var require_websocket_server = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash13("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash14("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -245684,13 +245585,13 @@ Justification: ${justification || "(none provided)"}`,
         }
         const snapshot = JSON.stringify(this.selfState, null, 2);
         try {
-          const { createHash: createHash13 } = await import("node:crypto");
+          const { createHash: createHash14 } = await import("node:crypto");
           const snapshotDir = join24(this.cwd, ".oa", "identity", "snapshots");
           await mkdir6(snapshotDir, { recursive: true });
           const version4 = this.selfState.version;
           const snapshotPath = join24(snapshotDir, `v${version4}.json`);
           await writeFile11(snapshotPath, snapshot, "utf8");
-          const hash = createHash13("sha256").update(snapshot).digest("hex");
+          const hash = createHash14("sha256").update(snapshot).digest("hex");
           await writeFile11(join24(this.cwd, ".oa", "identity", "latest-hash.txt"), hash, "utf8");
           let ipfsCid = "";
           try {
@@ -245823,8 +245724,8 @@ New: ${newNarrative.slice(0, 200)}...`,
       }
       // ── Helpers ──────────────────────────────────────────────────────────────
       createDefaultState() {
-        const { createHash: createHash13 } = __require("node:crypto");
-        const machineId = createHash13("sha256").update(this.cwd).digest("hex").slice(0, 12);
+        const { createHash: createHash14 } = __require("node:crypto");
+        const machineId = createHash14("sha256").update(this.cwd).digest("hex").slice(0, 12);
         return {
           self_id: `oa-${machineId}`,
           version: 1,
@@ -245906,9 +245807,9 @@ New: ${newNarrative.slice(0, 200)}...`,
         let cid;
         if (this.selfState.version > prevVersion) {
           try {
-            const { createHash: createHash13 } = await import("node:crypto");
+            const { createHash: createHash14 } = await import("node:crypto");
             const stateJson = JSON.stringify(this.selfState);
-            const hash = createHash13("sha256").update(stateJson).digest("hex").slice(0, 32);
+            const hash = createHash14("sha256").update(stateJson).digest("hex").slice(0, 32);
             const cidsPath = join24(this.cwd, ".oa", "identity", "cids.json");
             const cidsData = { latest: "", hash, version: this.selfState.version };
             try {
@@ -514374,9 +514275,634 @@ var init_embeddingAligner = __esm({
   }
 });
 
+// packages/memory/dist/crl/index.js
+var CRL_SYMBOLS, SYMBOL_MEANINGS, CRLParser, CRLEncoder, CRLDecoder, CRLTemplateResolver, CRL;
+var init_crl = __esm({
+  "packages/memory/dist/crl/index.js"() {
+    "use strict";
+    CRL_SYMBOLS = {
+      // Logical operators
+      THEREFORE: "∴",
+      BECAUSE: "∵",
+      EQUIVALENT: "≡",
+      IMPLIES: "→",
+      BICONDITIONAL: "↔",
+      NOT: "¬",
+      AND: "∧",
+      OR: "∨",
+      XOR: "⊕",
+      // Relational operators
+      ELEMENT_OF: "∈",
+      NOT_ELEMENT_OF: "∉",
+      PROPER_SUBSET: "⊂",
+      SUBSET_OR_EQUAL: "⊆",
+      UNION: "∪",
+      INTERSECTION: "∩",
+      EMPTY: "∅",
+      // Temporal/Sequential
+      THEN: "⇒",
+      FROM: "⇐",
+      LOOP: "⟳",
+      CYCLE: "↻",
+      NEXT: "⏵",
+      PREVIOUS: "⏴",
+      // Modal/Evidential
+      POSSIBLE: "◇",
+      NECESSARY: "□",
+      OBSERVED: "⊙",
+      UNCERTAIN: "?",
+      CRITICAL: "!",
+      APPROXIMATE: "~",
+      // Quantifiers
+      FOR_ALL: "∀",
+      EXISTS: "∃",
+      NOT_EXISTS: "∄",
+      AGGREGATE: "∑",
+      PRODUCT: "∏"
+    };
+    SYMBOL_MEANINGS = {
+      "∴": "therefore",
+      "∵": "because",
+      "≡": "equivalent",
+      "→": "implies",
+      "↔": "biconditional",
+      "¬": "not",
+      "∧": "and",
+      "∨": "or",
+      "⊕": "xor",
+      "∈": "element_of",
+      "∉": "not_element_of",
+      "⊂": "proper_subset",
+      "⊆": "subset_or_equal",
+      "∪": "union",
+      "∩": "intersection",
+      "∅": "empty",
+      "⇒": "then",
+      "⇐": "from",
+      "⟳": "loop",
+      "↻": "cycle",
+      "⏵": "next",
+      "⏴": "previous",
+      "◇": "possible",
+      "□": "necessary",
+      "⊙": "observed",
+      "?": "uncertain",
+      "!": "critical",
+      "~": "approximate",
+      "∀": "for_all",
+      "∃": "exists",
+      "∄": "not_exists",
+      "∑": "aggregate",
+      "∏": "product"
+    };
+    CRLParser = class {
+      pos = 0;
+      input = "";
+      parse(input) {
+        this.input = input;
+        this.pos = 0;
+        const nodes = [];
+        const start2 = this.pos;
+        while (this.pos < this.input.length) {
+          this.skipWhitespace();
+          if (this.pos >= this.input.length)
+            break;
+          const node = this.parseNode();
+          if (node)
+            nodes.push(node);
+        }
+        return {
+          type: "statement",
+          nodes,
+          raw: input,
+          position: { start: start2, end: this.pos }
+        };
+      }
+      parseNode() {
+        this.skipWhitespace();
+        if (this.peek() === "[") {
+          return this.parseConcept();
+        }
+        if (this.peek() === "$" && this.peek(1) === "{") {
+          return this.parseTemplate();
+        }
+        if (this.isQuantifier(this.peek())) {
+          return this.parseQuantifier();
+        }
+        if (this.isOperator(this.peek())) {
+          return this.parseOperator();
+        }
+        this.pos++;
+        return null;
+      }
+      parseConcept() {
+        const start2 = this.pos;
+        this.pos++;
+        let name10 = "";
+        while (this.pos < this.input.length && this.peek() !== "]") {
+          name10 += this.peek();
+          this.pos++;
+        }
+        this.pos++;
+        let properties;
+        if (this.peek() === "{") {
+          properties = this.parseProperties();
+        }
+        let strength;
+        if (this.peek() === "★") {
+          strength = 0;
+          while (this.peek() === "★") {
+            strength++;
+            this.pos++;
+          }
+        }
+        return {
+          type: "concept",
+          name: name10.trim(),
+          properties,
+          strength,
+          raw: this.input.substring(start2, this.pos),
+          position: { start: start2, end: this.pos }
+        };
+      }
+      parseProperties() {
+        const props = {};
+        this.pos++;
+        while (this.pos < this.input.length && this.peek() !== "}") {
+          const key = this.parseIdentifier();
+          if (this.peek() === ":") {
+            this.pos++;
+            const value2 = this.parseIdentifier();
+            props[key] = value2;
+          }
+          if (this.peek() === ",")
+            this.pos++;
+        }
+        this.pos++;
+        return props;
+      }
+      parseIdentifier() {
+        let id = "";
+        while (this.pos < this.input.length && /[a-zA-Z0-9_]/.test(this.peek())) {
+          id += this.peek();
+          this.pos++;
+        }
+        return id;
+      }
+      parseTemplate() {
+        const start2 = this.pos;
+        this.pos += 2;
+        let variable = "";
+        let defaultValue;
+        let typeAnnotation;
+        let transform;
+        while (this.pos < this.input.length && this.peek() !== "}" && this.peek() !== ":" && this.peek() !== "|" && this.peek() !== "→") {
+          variable += this.peek();
+          this.pos++;
+        }
+        if (this.peek() === ":") {
+          this.pos++;
+          defaultValue = "";
+          while (this.pos < this.input.length && this.peek() !== "}") {
+            defaultValue += this.peek();
+            this.pos++;
+          }
+        }
+        if (this.peek() === "|") {
+          this.pos++;
+          typeAnnotation = "";
+          while (this.pos < this.input.length && this.peek() !== "}" && this.peek() !== "→") {
+            typeAnnotation += this.peek();
+            this.pos++;
+          }
+        }
+        if (this.peek() === "→") {
+          this.pos++;
+          transform = "";
+          while (this.pos < this.input.length && this.peek() !== "}") {
+            transform += this.peek();
+            this.pos++;
+          }
+        }
+        this.pos++;
+        return {
+          type: "template",
+          variable: variable.trim(),
+          defaultValue,
+          typeAnnotation,
+          transform,
+          raw: this.input.substring(start2, this.pos),
+          position: { start: start2, end: this.pos }
+        };
+      }
+      parseQuantifier() {
+        const start2 = this.pos;
+        const quantifier = this.peek();
+        this.pos++;
+        let variable = "";
+        while (this.pos < this.input.length && /[a-zA-Z_]/.test(this.peek())) {
+          variable += this.peek();
+          this.pos++;
+        }
+        let domain;
+        if (this.peek() === "∈") {
+          this.pos++;
+          this.skipWhitespace();
+          domain = this.parseConcept();
+        }
+        this.skipWhitespace();
+        if (this.peek() === ":")
+          this.pos++;
+        this.skipWhitespace();
+        const predicate = this.parseNode();
+        return {
+          type: "quantifier",
+          quantifier,
+          variable,
+          domain,
+          predicate,
+          raw: this.input.substring(start2, this.pos),
+          position: { start: start2, end: this.pos }
+        };
+      }
+      parseOperator() {
+        const start2 = this.pos;
+        const op = this.peek();
+        this.pos++;
+        return {
+          type: "relation",
+          raw: op,
+          position: { start: start2, end: this.pos }
+        };
+      }
+      skipWhitespace() {
+        while (this.pos < this.input.length && /\s/.test(this.peek())) {
+          this.pos++;
+        }
+      }
+      peek(offset = 0) {
+        return this.input[this.pos + offset] || "";
+      }
+      isQuantifier(char) {
+        return ["∀", "∃", "∄", "∑", "∏"].includes(char);
+      }
+      isOperator(char) {
+        return [
+          "∴",
+          "∵",
+          "≡",
+          "→",
+          "↔",
+          "¬",
+          "∧",
+          "∨",
+          "⊕",
+          "∈",
+          "∉",
+          "⊂",
+          "⊆",
+          "∪",
+          "∩",
+          "⇒",
+          "⇐"
+        ].includes(char);
+      }
+    };
+    CRLEncoder = class {
+      conceptPatterns = /* @__PURE__ */ new Map();
+      /**
+       * Encode natural language text to CRL
+       */
+      encode(text) {
+        const concepts = this.extractConcepts(text);
+        const relations = this.extractRelations(text, concepts);
+        return this.buildExpression(concepts, relations);
+      }
+      /**
+       * Extract key concepts from text
+       */
+      extractConcepts(text) {
+        const concepts = [];
+        const conceptPattern = /\[([^\]]+)\]/g;
+        let match;
+        while ((match = conceptPattern.exec(text)) !== null) {
+          concepts.push({
+            type: "concept",
+            name: match[1],
+            raw: match[0],
+            position: { start: match.index, end: match.index + match[0].length }
+          });
+        }
+        const implicitPattern = /\b([A-Z][a-z]+(?:_[A-Z][a-z]+)*)\b/g;
+        while ((match = implicitPattern.exec(text)) !== null) {
+          if (!concepts.find((c9) => c9.name === match[1])) {
+            concepts.push({
+              type: "concept",
+              name: match[1],
+              raw: match[0],
+              position: { start: match.index, end: match.index + match[0].length }
+            });
+          }
+        }
+        return concepts;
+      }
+      /**
+       * Extract relations between concepts
+       */
+      extractRelations(text, concepts) {
+        const relations = [];
+        const relationPattern = /\[([^\]]+)\]\s*(→|↔|∴|∵|⇒|⇐)(?::(\w+))?\s*(?:→)?\s*\[([^\]]+)\]/g;
+        let match;
+        while ((match = relationPattern.exec(text)) !== null) {
+          const from3 = concepts.find((c9) => c9.name === match[1]);
+          const to = concepts.find((c9) => c9.name === match[4]);
+          if (from3 && to) {
+            relations.push({
+              type: "relation",
+              from: from3,
+              to,
+              operator: match[2],
+              edgeType: match[3],
+              raw: match[0],
+              position: { start: match.index, end: match.index + match[0].length }
+            });
+          }
+        }
+        return relations;
+      }
+      /**
+       * Build CRL expression from concepts and relations
+       */
+      buildExpression(concepts, relations) {
+        const lines = [];
+        for (const rel of relations) {
+          let line = `[${rel.from.name}] ${rel.operator}`;
+          if (rel.edgeType)
+            line += `:${rel.edgeType}`;
+          line += ` [${rel.to.name}]`;
+          lines.push(line);
+        }
+        const relatedConcepts = /* @__PURE__ */ new Set();
+        for (const rel of relations) {
+          relatedConcepts.add(rel.from.name);
+          relatedConcepts.add(rel.to.name);
+        }
+        for (const concept of concepts) {
+          if (!relatedConcepts.has(concept.name)) {
+            lines.push(`[${concept.name}]`);
+          }
+        }
+        return lines.join("\n");
+      }
+      /**
+       * Compress text using CRL patterns
+       */
+      compress(text) {
+        const replacements = [
+          [/therefore/gi, "∴"],
+          [/because/gi, "∵"],
+          [/implies that/gi, "→"],
+          [/is equivalent to/gi, "≡"],
+          [/is an? element of/gi, "∈"],
+          [/is not an? element of/gi, "∉"],
+          [/is a subset of/gi, "⊂"],
+          [/for all/gi, "∀"],
+          [/there exists/gi, "∃"],
+          [/and then/gi, "⇒"],
+          [/leads to/gi, "→"],
+          [/causes/gi, "→:causes"],
+          [/fixes/gi, "→:fixes"],
+          [/relates to/gi, "∩"]
+        ];
+        let result = text;
+        for (const [pattern, replacement] of replacements) {
+          result = result.replace(pattern, replacement);
+        }
+        return result;
+      }
+    };
+    CRLDecoder = class {
+      /**
+       * Decode CRL expression to natural language
+       */
+      decode(crl) {
+        const parser2 = new CRLParser();
+        const ast = parser2.parse(crl);
+        return this.renderStatement(ast);
+      }
+      /**
+       * Render a statement node
+       */
+      renderStatement(node) {
+        return node.nodes.map((n2) => this.renderNode(n2)).filter(Boolean).join(". ");
+      }
+      /**
+       * Render any CRL node
+       */
+      renderNode(node) {
+        switch (node.type) {
+          case "concept":
+            return this.renderConcept(node);
+          case "template":
+            return this.renderTemplate(node);
+          case "quantifier":
+            return this.renderQuantifier(node);
+          case "relation":
+            return this.renderRelation(node);
+          default:
+            return "";
+        }
+      }
+      /**
+       * Render a concept
+       */
+      renderConcept(node) {
+        let result = node.name;
+        if (node.properties) {
+          const props = Object.entries(node.properties).map(([k, v]) => `${k}=${v}`).join(", ");
+          result += ` (${props})`;
+        }
+        if (node.strength) {
+          result += ` [strength: ${node.strength}/5]`;
+        }
+        return result;
+      }
+      /**
+       * Render a template
+       */
+      renderTemplate(node) {
+        let result = node.variable;
+        if (node.typeAnnotation) {
+          result += ` (${node.typeAnnotation})`;
+        }
+        if (node.defaultValue) {
+          result += ` [default: ${node.defaultValue}]`;
+        }
+        return result;
+      }
+      /**
+       * Render a quantifier
+       */
+      renderQuantifier(node) {
+        const quantifierMeanings = {
+          "∀": "For all",
+          "∃": "There exists",
+          "∄": "There does not exist",
+          "∑": "Sum of",
+          "∏": "Product of"
+        };
+        let result = `${quantifierMeanings[node.quantifier]} ${node.variable}`;
+        if (node.domain) {
+          result += ` in ${this.renderNode(node.domain)}`;
+        }
+        if (node.predicate) {
+          result += `, ${this.renderNode(node.predicate)}`;
+        }
+        return result;
+      }
+      /**
+       * Render a relation
+       */
+      renderRelation(node) {
+        const operatorMeanings = {
+          "→": "implies",
+          "∴": "therefore",
+          "∵": "because",
+          "≡": "is equivalent to",
+          "↔": "is mutually related to",
+          "∈": "is an element of",
+          "⊂": "is a subset of",
+          "∪": "combined with",
+          "∩": "intersects with",
+          "⇒": "then",
+          "⇐": "from"
+        };
+        const from3 = this.renderConcept(node.from);
+        const to = this.renderConcept(node.to);
+        const op = operatorMeanings[node.operator] || node.operator;
+        if (node.edgeType) {
+          return `${from3} ${node.edgeType} ${to}`;
+        }
+        return `${from3} ${op} ${to}`;
+      }
+      /**
+       * Expand CRL symbols to natural language
+       */
+      expand(text) {
+        const expansions = {
+          "∴": "therefore",
+          "∵": "because",
+          "≡": "is equivalent to",
+          "→": "implies",
+          "↔": "is mutually related to",
+          "¬": "not",
+          "∧": "and",
+          "∨": "or",
+          "∈": "is an element of",
+          "∉": "is not an element of",
+          "⊂": "is a subset of",
+          "⊆": "is a subset of or equal to",
+          "∪": "union with",
+          "∩": "intersection with",
+          "∅": "empty",
+          "⇒": "then",
+          "⇐": "from",
+          "◇": "possibly",
+          "□": "necessarily",
+          "⊙": "observed",
+          "∀": "for all",
+          "∃": "there exists",
+          "∄": "there does not exist"
+        };
+        let result = text;
+        for (const [symbol3, expansion] of Object.entries(expansions)) {
+          result = result.replace(new RegExp(symbol3, "g"), ` ${expansion} `);
+        }
+        return result.replace(/\s+/g, " ").trim();
+      }
+    };
+    CRLTemplateResolver = class {
+      /**
+       * Resolve templates in CRL expression
+       */
+      resolve(crl, context2) {
+        const templatePattern = /\$\{([^}]+)\}/g;
+        return crl.replace(templatePattern, (match, template) => {
+          return this.resolveTemplate(template, context2);
+        });
+      }
+      resolveTemplate(template, context2) {
+        const parts = template.split(/[:|→]/);
+        const variable = parts[0].trim();
+        const defaultValue = parts[1]?.trim();
+        const typeAnnotation = parts[2]?.trim();
+        let value2;
+        if (variable.startsWith("ctx:")) {
+          const ctxVar = variable.substring(5);
+          value2 = context2[ctxVar];
+        } else if (variable.startsWith("mem:")) {
+          const memVar = variable.substring(4);
+          const memArray = context2.memories?.[memVar];
+          value2 = memArray?.join(", ");
+        } else if (variable.startsWith("state:")) {
+          const stateVar = variable.substring(6);
+          value2 = context2.state?.[stateVar];
+        } else {
+          value2 = context2.variables?.[variable];
+        }
+        return value2 || defaultValue || `[${variable}]`;
+      }
+    };
+    CRL = {
+      parser: new CRLParser(),
+      encoder: new CRLEncoder(),
+      decoder: new CRLDecoder(),
+      resolver: new CRLTemplateResolver(),
+      symbols: CRL_SYMBOLS,
+      meanings: SYMBOL_MEANINGS,
+      /**
+       * Quick encode: natural language → CRL
+       */
+      encode(text) {
+        return this.encoder.encode(text);
+      },
+      /**
+       * Quick decode: CRL → natural language
+       */
+      decode(crl) {
+        return this.decoder.decode(crl);
+      },
+      /**
+       * Quick compress: replace common patterns with symbols
+       */
+      compress(text) {
+        return this.encoder.compress(text);
+      },
+      /**
+       * Quick expand: replace symbols with natural language
+       */
+      expand(text) {
+        return this.decoder.expand(text);
+      },
+      /**
+       * Resolve templates with context
+       */
+      resolve(crl, context2) {
+        return this.resolver.resolve(crl, context2);
+      }
+    };
+  }
+});
+
 // packages/memory/dist/index.js
 var dist_exports2 = {};
 __export(dist_exports2, {
+  CRL: () => CRL,
+  CRLDecoder: () => CRLDecoder,
+  CRLEncoder: () => CRLEncoder,
+  CRLParser: () => CRLParser,
+  CRLTemplateResolver: () => CRLTemplateResolver,
+  CRL_SYMBOLS: () => CRL_SYMBOLS,
   DECAY_TAU: () => DECAY_TAU,
   EmbeddingAligner: () => EmbeddingAligner,
   EpisodeStore: () => EpisodeStore,
@@ -514385,6 +514911,7 @@ __export(dist_exports2, {
   PatchHistoryStore: () => PatchHistoryStore,
   ProceduralMemoryStore: () => ProceduralMemoryStore,
   RepoProfileStore: () => RepoProfileStore,
+  SYMBOL_MEANINGS: () => SYMBOL_MEANINGS,
   TaskMemoryStore: () => TaskMemoryStore,
   TemporalGraph: () => TemporalGraph,
   ToolPatternStore: () => ToolPatternStore,
@@ -514432,6 +514959,7 @@ var init_dist7 = __esm({
     init_proceduralMemoryStore();
     init_splanifold();
     init_embeddingAligner();
+    init_crl();
   }
 });
 
@@ -524187,6 +524715,105 @@ var init_dist8 = __esm({
   }
 });
 
+// packages/cli/src/ui/spinner.ts
+var FRAMES, INTERVAL_MS, Spinner;
+var init_spinner = __esm({
+  "packages/cli/src/ui/spinner.ts"() {
+    "use strict";
+    FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+    INTERVAL_MS = 80;
+    Spinner = class {
+      _text;
+      _frameIndex = 0;
+      _timer = null;
+      _isSpinning = false;
+      constructor(text) {
+        this._text = text;
+      }
+      // --------------------------------------------------------------------------
+      // Public API
+      // --------------------------------------------------------------------------
+      get text() {
+        return this._text;
+      }
+      set text(value2) {
+        this._text = value2;
+        if (this._isSpinning && process.stdout.isTTY) {
+          this._render();
+        }
+      }
+      get isSpinning() {
+        return this._isSpinning;
+      }
+      start() {
+        if (this._isSpinning) return this;
+        this._isSpinning = true;
+        this._frameIndex = 0;
+        if (process.stdout.isTTY) {
+          process.stdout.write("\x1B[?25l");
+          this._render();
+          this._timer = setInterval(() => {
+            this._frameIndex = (this._frameIndex + 1) % FRAMES.length;
+            this._render();
+          }, INTERVAL_MS);
+        } else {
+          process.stdout.write(`${this._text}
+`);
+        }
+        return this;
+      }
+      stop() {
+        if (!this._isSpinning) return this;
+        this._isSpinning = false;
+        if (this._timer !== null) {
+          clearInterval(this._timer);
+          this._timer = null;
+        }
+        if (process.stdout.isTTY) {
+          process.stdout.write("\r\x1B[K");
+          process.stdout.write("\x1B[?25h");
+        }
+        return this;
+      }
+      succeed(message2) {
+        this.stop();
+        const msg = message2 ?? this._text;
+        process.stdout.write(`\x1B[32m✔\x1B[0m ${msg}
+`);
+        return this;
+      }
+      fail(message2) {
+        this.stop();
+        const msg = message2 ?? this._text;
+        process.stdout.write(`\x1B[31m✖\x1B[0m ${msg}
+`);
+        return this;
+      }
+      warn(message2) {
+        this.stop();
+        const msg = message2 ?? this._text;
+        process.stdout.write(`\x1B[33m⚠\x1B[0m ${msg}
+`);
+        return this;
+      }
+      info(message2) {
+        this.stop();
+        const msg = message2 ?? this._text;
+        process.stdout.write(`\x1B[36mℹ\x1B[0m ${msg}
+`);
+        return this;
+      }
+      // --------------------------------------------------------------------------
+      // Private
+      // --------------------------------------------------------------------------
+      _render() {
+        const frame = FRAMES[this._frameIndex] ?? FRAMES[0];
+        process.stdout.write(`\r\x1B[36m${frame}\x1B[0m ${this._text}`);
+      }
+    };
+  }
+});
+
 // packages/cli/src/api/py-embed.ts
 var py_embed_exports = {};
 __export(py_embed_exports, {
@@ -527292,7 +527919,7 @@ var require_websocket3 = __commonJS({
     var http6 = __require("http");
     var net5 = __require("net");
     var tls2 = __require("tls");
-    var { randomBytes: randomBytes23, createHash: createHash13 } = __require("crypto");
+    var { randomBytes: randomBytes23, createHash: createHash14 } = __require("crypto");
     var { Duplex: Duplex3, Readable } = __require("stream");
     var { URL: URL3 } = __require("url");
     var PerMessageDeflate2 = require_permessage_deflate3();
@@ -527952,7 +528579,7 @@ var require_websocket3 = __commonJS({
           abortHandshake(websocket, socket, "Invalid Upgrade header");
           return;
         }
-        const digest3 = createHash13("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash14("sha1").update(key + GUID).digest("base64");
         if (res.headers["sec-websocket-accept"] !== digest3) {
           abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
           return;
@@ -528319,7 +528946,7 @@ var require_websocket_server2 = __commonJS({
     var EventEmitter12 = __require("events");
     var http6 = __require("http");
     var { Duplex: Duplex3 } = __require("stream");
-    var { createHash: createHash13 } = __require("crypto");
+    var { createHash: createHash14 } = __require("crypto");
     var extension2 = require_extension3();
     var PerMessageDeflate2 = require_permessage_deflate3();
     var subprotocol2 = require_subprotocol2();
@@ -528620,7 +529247,7 @@ var require_websocket_server2 = __commonJS({
           );
         }
         if (this._state > RUNNING) return abortHandshake(socket, 503);
-        const digest3 = createHash13("sha1").update(key + GUID).digest("base64");
+        const digest3 = createHash14("sha1").update(key + GUID).digest("base64");
         const headers = [
           "HTTP/1.1 101 Switching Protocols",
           "Upgrade: websocket",
@@ -529663,9 +530290,10 @@ __export(oa_directory_exports, {
   writeIndexData: () => writeIndexData,
   writeIndexMeta: () => writeIndexMeta
 });
-import { existsSync as existsSync57, mkdirSync as mkdirSync32, readFileSync as readFileSync44, writeFileSync as writeFileSync29, readdirSync as readdirSync14, statSync as statSync17, unlinkSync as unlinkSync14, openSync as openSync2, closeSync as closeSync2 } from "node:fs";
+import { existsSync as existsSync57, mkdirSync as mkdirSync32, readFileSync as readFileSync44, writeFileSync as writeFileSync29, readdirSync as readdirSync14, statSync as statSync17, unlinkSync as unlinkSync14, openSync as openSync2, closeSync as closeSync2, renameSync as renameSync3 } from "node:fs";
 import { join as join75, relative as relative6, basename as basename13, dirname as dirname22 } from "node:path";
 import { homedir as homedir25 } from "node:os";
+import { createHash as createHash8 } from "node:crypto";
 function findGitRoot(startDir) {
   let dir = startDir;
   const visited = /* @__PURE__ */ new Set();
@@ -529944,6 +530572,14 @@ function loadPendingTask(repoRoot) {
     return null;
   }
 }
+function computeDedupeHash(task, savedAt) {
+  return createHash8("sha256").update(`${task}|${savedAt}`).digest("hex").slice(0, 16);
+}
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `${timestamp}-${random}`;
+}
 function acquireLock(lockPath) {
   const startTime = Date.now();
   const pid = process.pid;
@@ -530027,16 +530663,11 @@ function normalizeSessionContextEntry(entry) {
   const assistantResponse = normalizeSessionText(entry.assistantResponse, 1200);
   if (assistantResponse) normalized.assistantResponse = assistantResponse;
   if (entry.source) normalized.source = entry.source;
-  return normalized;
-}
-function sameStringArray(a2, b) {
-  const left = a2 ?? [];
-  const right = b ?? [];
-  if (left.length !== right.length) return false;
-  for (let i2 = 0; i2 < left.length; i2++) {
-    if (left[i2] !== right[i2]) return false;
+  normalized._dedupeHash = computeDedupeHash(normalized.task, normalized.savedAt);
+  if (!normalized.sessionId) {
+    normalized.sessionId = generateSessionId();
   }
-  return true;
+  return normalized;
 }
 function lastMatchingIndex(items, predicate) {
   for (let i2 = items.length - 1; i2 >= 0; i2--) {
@@ -530058,9 +530689,6 @@ function isWithinReplaceWindow(a2, b) {
   if (left == null || right == null) return true;
   return Math.abs(right - left) <= SAME_TASK_REPLACE_WINDOW_MS;
 }
-function isExactSessionDuplicate(a2, b) {
-  return sameTask(a2, b) && a2.summary === b.summary && (a2.assistantResponse ?? "") === (b.assistantResponse ?? "") && sameStringArray(a2.filesModified, b.filesModified) && sameStringArray(a2.toolsUsed, b.toolsUsed) && (a2.provenance ?? "") === (b.provenance ?? "") && a2.toolCalls === b.toolCalls && a2.completed === b.completed && a2.model === b.model;
-}
 function mergeSessionContextEntry(previous, incoming) {
   return {
     ...previous,
@@ -530099,12 +530727,19 @@ function saveSessionContext(repoRoot, entry) {
       ctx3 = { entries: [], maxEntries: MAX_CONTEXT_ENTRIES, updatedAt: "" };
     }
     const normalizedEntry = normalizeSessionContextEntry(entry);
-    const exactIndex = lastMatchingIndex(
-      ctx3.entries,
-      (existing) => isExactSessionDuplicate(normalizeSessionContextEntry(existing), normalizedEntry)
-    );
-    if (exactIndex >= 0) {
-      ctx3.entries[exactIndex] = mergeSessionContextEntry(ctx3.entries[exactIndex], normalizedEntry);
+    const hashToIndex = /* @__PURE__ */ new Map();
+    for (let i2 = 0; i2 < ctx3.entries.length; i2++) {
+      const existing = ctx3.entries[i2];
+      const hash = existing._dedupeHash || computeDedupeHash(
+        cleanPromptForDiary(existing.task),
+        existing.savedAt
+      );
+      hashToIndex.set(hash, i2);
+    }
+    const incomingHash = normalizedEntry._dedupeHash;
+    const hashMatchIndex = hashToIndex.get(incomingHash);
+    if (hashMatchIndex !== void 0) {
+      ctx3.entries[hashMatchIndex] = mergeSessionContextEntry(ctx3.entries[hashMatchIndex], normalizedEntry);
     } else {
       const relatedIndex = lastMatchingIndex(ctx3.entries, (existing) => {
         const normalizedExisting = normalizeSessionContextEntry(existing);
@@ -530129,7 +530764,17 @@ function saveSessionContext(repoRoot, entry) {
       ctx3.entries = ctx3.entries.slice(-ctx3.maxEntries);
     }
     ctx3.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    writeFileSync29(filePath, JSON.stringify(ctx3, null, 2) + "\n", "utf-8");
+    const tempFilePath = filePath + ".tmp";
+    writeFileSync29(tempFilePath, JSON.stringify(ctx3, null, 2) + "\n", "utf-8");
+    try {
+      renameSync3(tempFilePath, filePath);
+    } catch {
+      writeFileSync29(filePath, JSON.stringify(ctx3, null, 2) + "\n", "utf-8");
+      try {
+        unlinkSync14(tempFilePath);
+      } catch {
+      }
+    }
     try {
       writeFileSync29(
         join75(contextDir, "session-diary.md"),
@@ -534227,6 +534872,7 @@ ${CONTENT_BG_SEQ}`);
           process.stdout.write(RESET2);
           this._brailleSpinner.setMetrics({ isStreaming: false });
           this.renderFooterAndPositionInput();
+          this.parkCursorInInput();
           this.scheduleMouseIdle();
         }
       }
@@ -534905,6 +535551,27 @@ ${CONTENT_BG_SEQ}`);
         this.termWrite(
           `\x1B[${this.scrollRegionTop};${pos.scrollEnd}r\x1B[${pos.scrollEnd};1H` + (clearScrollback ? "\x1B[3J" : "")
         );
+        if (this.writeDepth === 0) {
+          this.parkCursorInInput();
+        }
+      }
+      /**
+       * Park cursor in the input row — ensures cursor is always in the input area
+       * after scroll region changes or other operations that may leave it elsewhere.
+       * Called after applyScrollRegion() and in endContentWrite() for safety.
+       */
+      parkCursorInInput() {
+        if (!this.active) return;
+        const rows = termRows();
+        const w = getTermWidth();
+        const pos = this.rowPositions(rows);
+        const inputWrap = this.wrapInput(w);
+        const cursorRow = pos.inputStartRow + inputWrap.cursorRow;
+        const cursorCol = inputWrap.cursorCol;
+        if (process.env.OA_DEBUG_CURSOR === "1") {
+          console.error(`[CURSOR DEBUG] parkCursorInInput: row=${cursorRow}, col=${cursorCol}, inputStartRow=${pos.inputStartRow}, cursorRow=${inputWrap.cursorRow}, writeDepth=${this.writeDepth}`);
+        }
+        this.termWrite(`\x1B[${cursorRow};${cursorCol}H\x1B[?25h`);
       }
       /**
        * WO-TASK-02 — Public hook for the TUI tasks renderer. When the tasks
@@ -557973,7 +558640,7 @@ var init_types = __esm({
 });
 
 // packages/cli/src/tui/p2p/secret-vault.ts
-import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes18, scryptSync as scryptSync2, createHash as createHash8 } from "node:crypto";
+import { createCipheriv as createCipheriv3, createDecipheriv as createDecipheriv3, randomBytes as randomBytes18, scryptSync as scryptSync2, createHash as createHash9 } from "node:crypto";
 import { readFileSync as readFileSync54, writeFileSync as writeFileSync37, existsSync as existsSync69, mkdirSync as mkdirSync40 } from "node:fs";
 import { dirname as dirname26 } from "node:path";
 var PLACEHOLDER_PREFIX, PLACEHOLDER_SUFFIX, CIPHER_ALGO, SALT_LEN, IV_LEN, KEY_LEN, SecretVault;
@@ -558218,7 +558885,7 @@ var init_secret_vault = __esm({
       /** Generate a deterministic fingerprint of vault contents (for sync verification) */
       fingerprint() {
         const names = Array.from(this.secrets.keys()).sort();
-        const hash = createHash8("sha256");
+        const hash = createHash9("sha256");
         for (const name10 of names) {
           hash.update(name10 + ":");
           hash.update(this.secrets.get(name10).value);
@@ -558233,7 +558900,7 @@ var init_secret_vault = __esm({
 // packages/cli/src/tui/p2p/peer-mesh.ts
 import { EventEmitter as EventEmitter7 } from "node:events";
 import { createServer as createServer5 } from "node:http";
-import { randomBytes as randomBytes19, createHash as createHash9, generateKeyPairSync } from "node:crypto";
+import { randomBytes as randomBytes19, createHash as createHash10, generateKeyPairSync } from "node:crypto";
 var PING_INTERVAL_MS, PEER_TIMEOUT_MS, GOSSIP_INTERVAL_MS, MAX_PEERS, PeerMesh;
 var init_peer_mesh = __esm({
   "packages/cli/src/tui/p2p/peer-mesh.ts"() {
@@ -558250,7 +558917,7 @@ var init_peer_mesh = __esm({
         const { publicKey: publicKey2, privateKey } = generateKeyPairSync("ed25519");
         this.publicKey = publicKey2.export({ type: "spki", format: "der" });
         this.privateKey = privateKey.export({ type: "pkcs8", format: "der" });
-        this.peerId = createHash9("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
+        this.peerId = createHash10("sha256").update(this.publicKey).digest("base64url").slice(0, 22);
         this.capabilities = options2.capabilities;
         this.displayName = options2.displayName;
         this._authKey = options2.authKey ?? randomBytes19(24).toString("base64url");
@@ -566114,7 +566781,7 @@ import {
   readFileSync as readFileSync62,
   readdirSync as readdirSync25,
   writeFileSync as writeFileSync42,
-  renameSync as renameSync4,
+  renameSync as renameSync5,
   mkdirSync as mkdirSync47,
   unlinkSync as unlinkSync21
 } from "node:fs";
@@ -566137,7 +566804,7 @@ function persistSession(s2) {
     const final2 = sessionPath(s2.id);
     const tmp = `${final2}.tmp.${process.pid}.${Date.now()}`;
     writeFileSync42(tmp, JSON.stringify(s2, null, 2), "utf-8");
-    renameSync4(tmp, final2);
+    renameSync5(tmp, final2);
   } catch {
   }
 }
@@ -566147,7 +566814,7 @@ function persistInFlight(j) {
     const final2 = inFlightPath(j.sessionId);
     const tmp = `${final2}.tmp.${process.pid}.${Date.now()}`;
     writeFileSync42(tmp, JSON.stringify(j, null, 2), "utf-8");
-    renameSync4(tmp, final2);
+    renameSync5(tmp, final2);
   } catch {
   }
 }
@@ -566529,7 +567196,7 @@ __export(projects_exports, {
   setCurrentProject: () => setCurrentProject,
   unregisterProject: () => unregisterProject
 });
-import { readFileSync as readFileSync63, writeFileSync as writeFileSync43, mkdirSync as mkdirSync48, existsSync as existsSync79, statSync as statSync23, renameSync as renameSync5 } from "node:fs";
+import { readFileSync as readFileSync63, writeFileSync as writeFileSync43, mkdirSync as mkdirSync48, existsSync as existsSync79, statSync as statSync23, renameSync as renameSync6 } from "node:fs";
 import { homedir as homedir34 } from "node:os";
 import { basename as basename19, join as join97, resolve as resolve34 } from "node:path";
 import { randomUUID as randomUUID12 } from "node:crypto";
@@ -566548,7 +567215,7 @@ function writeAll(file) {
   mkdirSync48(OA_DIR3, { recursive: true });
   const tmp = `${PROJECTS_FILE}.${randomUUID12().slice(0, 8)}.tmp`;
   writeFileSync43(tmp, JSON.stringify(file, null, 2), "utf8");
-  renameSync5(tmp, PROJECTS_FILE);
+  renameSync6(tmp, PROJECTS_FILE);
 }
 function listProjects() {
   const { projects } = readAll();
@@ -567542,7 +568209,7 @@ var init_disk_task_output = __esm({
 });
 
 // packages/cli/src/api/http.ts
-import { createHash as createHash10 } from "node:crypto";
+import { createHash as createHash11 } from "node:crypto";
 function problemDetails(opts) {
   const p2 = {
     type: opts.type ?? "about:blank",
@@ -567605,7 +568272,7 @@ function paginated(items, page2, total) {
 }
 function computeEtag(payload) {
   const json = typeof payload === "string" ? payload : JSON.stringify(payload);
-  const hash = createHash10("sha1").update(json).digest("hex").slice(0, 16);
+  const hash = createHash11("sha1").update(json).digest("hex").slice(0, 16);
   return `W/"${hash}"`;
 }
 function checkNotModified(req2, res, etag) {
@@ -575384,7 +576051,7 @@ import { homedir as homedir39 } from "node:os";
 import { spawn as spawn25, execSync as execSync55 } from "node:child_process";
 import { mkdirSync as mkdirSync54, writeFileSync as writeFileSync47, readFileSync as readFileSync69, readdirSync as readdirSync29, existsSync as existsSync87, watch as fsWatch3 } from "node:fs";
 import { randomBytes as randomBytes21, randomUUID as randomUUID13 } from "node:crypto";
-import { createHash as createHash12 } from "node:crypto";
+import { createHash as createHash13 } from "node:crypto";
 function getVersion3() {
   try {
     const require3 = createRequire4(import.meta.url);
@@ -576131,8 +576798,9 @@ function checkAuth(req2, res, requiredScope = "read") {
     });
     return false;
   }
-  req2._authUser = auth.user;
-  req2._authScope = auth.scope;
+  const reqWithAuth = req2;
+  reqWithAuth._authUser = auth.user;
+  reqWithAuth._authScope = auth.scope;
   return true;
 }
 function handleHealth(res) {
@@ -579410,7 +580078,7 @@ function listScheduledTasks() {
               const schedule = String(t2?.schedule || t2?.cron || t2?.when || "");
               const enabled2 = typeof t2?.enabled === "boolean" ? t2.enabled : true;
               const realId = typeof t2?.id === "string" && t2.id ? t2.id : null;
-              const fallbackId = createHash12("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
+              const fallbackId = createHash13("sha1").update(`${file}#${i2}`).digest("hex").slice(0, 16);
               const uid = realId || fallbackId;
               const key = `${uid}`;
               if (seen.has(key)) return;
@@ -579527,8 +580195,8 @@ function deleteScheduledById(id) {
     if (id) candidates.push(id);
     if (typeof entry?.id === "string" && entry.id && !candidates.includes(entry.id)) candidates.push(entry.id);
     try {
-      const { createHash: createHash13 } = __require("node:crypto");
-      const fallback = createHash13("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
+      const { createHash: createHash14 } = __require("node:crypto");
+      const fallback = createHash14("sha1").update(`${target.file}#${target.index}`).digest("hex").slice(0, 16);
       if (!candidates.includes(fallback)) candidates.push(fallback);
     } catch {
     }
@@ -587107,13 +587775,13 @@ ${fullInput}`;
       writeContent(() => renderError2(errMsg));
       if (failureStore) {
         try {
-          const { createHash: createHash13 } = await import("node:crypto");
+          const { createHash: createHash14 } = await import("node:crypto");
           failureStore.insert({
             taskId: "",
             sessionId: `${Date.now()}`,
             repoRoot,
             failureType: "runtime-error",
-            fingerprint: createHash13("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
+            fingerprint: createHash14("sha256").update(errMsg.slice(0, 200)).digest("hex").slice(0, 16),
             filePath: null,
             errorMessage: errMsg.slice(0, 500),
             context: null,
@@ -588716,6 +589384,7 @@ import { dirname as dirname33, join as join109 } from "node:path";
 
 // packages/cli/src/cli.ts
 init_typed_node_events();
+init_dist8();
 import { createInterface } from "node:readline";
 function createCli(options2) {
   return {
@@ -588725,6 +589394,29 @@ function createCli(options2) {
       console.log(`Backend: ${options2.backendUrl}`);
       console.log(`Project: ${options2.projectRoot}`);
       console.log("");
+      const backend = new OllamaAgenticBackend(options2.backendUrl, options2.model);
+      const runner = new AgenticRunner(backend, {
+        maxTurns: 50
+      });
+      runner.onEvent((event) => {
+        switch (event.type) {
+          case "tool_call":
+            if (event.toolName) console.log(`[tool] ${event.toolName}`);
+            break;
+          case "tool_result":
+            if (event.toolName) console.log(`[tool] ${event.toolName} ${event.success ? "✓" : "✗"}`);
+            break;
+          case "status":
+            if (event.content) console.log(`[status] ${event.content.slice(0, 100)}`);
+            break;
+          case "assistant_text":
+            if (event.content) process.stdout.write(event.content);
+            break;
+          case "error":
+            if (event.content) console.error(`[error] ${event.content}`);
+            break;
+        }
+      });
       const rl = createInterface({
         input: process.stdin,
         output: process.stdout,
@@ -588742,8 +589434,16 @@ function createCli(options2) {
           rl.close();
           return;
         }
-        console.log(`[agent] Processing: "${input}"`);
-        console.log("[agent] Agent loop not yet connected.");
+        try {
+          const result = await runner.run(input);
+          console.log("");
+          console.log(`[agent] Task completed: ${result.completed ? "success" : "incomplete"}`);
+          if (result.summary) {
+            console.log(`[agent] Summary: ${result.summary.slice(0, 200)}`);
+          }
+        } catch (err) {
+          console.error("[agent] Error:", err instanceof Error ? err.message : String(err));
+        }
         console.log("");
         rl.prompt();
       });