omnius 1.0.150 → 1.0.152

package/dist/index.js

@@ -11718,17 +11718,44 @@ async function loadNexusClientClass() {
 }
 
 const NexusClient = await loadNexusClientClass();
+function _envTruthy(name) {
+  var v = String(process.env[name] || '').toLowerCase();
+  return v === '1' || v === 'true' || v === 'yes' || v === 'on';
+}
+function _envList(name) {
+  return String(process.env[name] || '')
+    .split(',')
+    .map(function(v) { return v.trim(); })
+    .filter(Boolean);
+}
+function _envRole() {
+  var role = String(process.env.OMNIUS_NEXUS_ROLE || 'full').toLowerCase();
+  return role === 'light' || role === 'storage' || role === 'full' ? role : 'full';
+}
+var _nexusSignalingServer = process.env.OMNIUS_NEXUS_SIGNALING_SERVER || 'https://openagents.nexus';
+var _nexusNatsServers = _envList('OMNIUS_NEXUS_NATS_SERVERS');
+var _nexusManifestUrls = _envList('OMNIUS_NEXUS_MANIFEST_URLS');
 var nexusOpts = {
   keyStorePath: keyPath,
   agentName,
   agentType,
-  role: 'light',
+  role: _envRole(),
+  cachePath: nexusDir,
+  signalingServer: _nexusSignalingServer,
+  manifestUrls: _nexusManifestUrls,
   enableMdns: true,
   enablePubsubDiscovery: true,
   enableNats: true,
-  natsServers: ['wss://demo.nats.io:8443'],
+  natsServers: _nexusNatsServers.length > 0 ? _nexusNatsServers : ['wss://demo.nats.io:8443'],
   enableCircuitRelay: true,
+  enableAutoNAT: true,
+  enableDcutr: true,
+  enableUpnpNat: true,
+  enableRelayServer: true,
+  filterPrivateAddresses: true,
   usePublicBootstrap: true,
+  enableNkn: _envTruthy('OMNIUS_NEXUS_ENABLE_NKN'),
+  nknIdentifier: process.env.OMNIUS_NEXUS_NKN_IDENTIFIER || ('omnius-' + agentName),
   trustPolicy: { denylist: [], allowlist: [] },
 };
 if (hasX402Key) {
@@ -12100,6 +12127,24 @@ function writeStatus(extra = {}) {
     rooms: [...rooms.keys()],
     capabilities: caps,
     blockedPeers,
+    networkStack: {
+      role: nexusOpts.role,
+      signalingServer: nexusOpts.signalingServer,
+      cachePath: nexusOpts.cachePath,
+      manifestUrls: nexusOpts.manifestUrls || [],
+      natsServers: nexusOpts.natsServers || [],
+      discovery: {
+        publicBootstrap: nexusOpts.usePublicBootstrap !== false,
+        pubsub: nexusOpts.enablePubsubDiscovery !== false,
+        mdns: nexusOpts.enableMdns !== false,
+        circuitRelay: nexusOpts.enableCircuitRelay !== false,
+        autoNAT: nexusOpts.enableAutoNAT !== false,
+        dcutr: nexusOpts.enableDcutr !== false,
+        upnpNAT: nexusOpts.enableUpnpNat !== false,
+        relayServer: nexusOpts.enableRelayServer !== false,
+        nkn: nexusOpts.enableNkn === true,
+      },
+    },
     connectedAt: connected ? new Date().toISOString() : null,
     ...extra,
   };
@@ -12110,6 +12155,242 @@ function writeResp(id, result) {
   try { writeFileSync(respFile, JSON.stringify({ id, ...result }, null, 2)); } catch {}
 }
 
+const capabilityRecordsFile = join(nexusDir, 'capability-records.json');
+const sponsorMeshCacheFile = join(nexusDir, 'sponsor-mesh-cache.json');
+var _capabilityPointerSeq = {};
+var _meshDiscoveryInstalled = false;
+
+function _readJson(path, fallback) {
+  try {
+    if (!existsSync(path)) return fallback;
+    var raw = readFileSync(path, 'utf8');
+    return raw.trim() ? JSON.parse(raw) : fallback;
+  } catch { return fallback; }
+}
+function _writeJson(path, value) {
+  try { writeFileSync(path, JSON.stringify(value, null, 2)); } catch {}
+}
+async function _dhtPutBounded(dht, key, value, label) {
+  var op = (async function() {
+    for await (var _ of dht.put(key, value)) {}
+  })().catch(function(err) {
+    dlog('DHT put failed for ' + label + ': ' + (err.message || err));
+  });
+  var timedOut = await Promise.race([
+    op.then(function() { return false; }),
+    new Promise(function(resolve) { setTimeout(function() { resolve(true); }, 2500); }),
+  ]);
+  if (timedOut) dlog('DHT put deferred for ' + label);
+}
+function _sanitizeCapabilityKey(name) {
+  return String(name || '').replace(/[^a-zA-Z0-9._:-]/g, '_');
+}
+function _capabilityDefinition(name, details) {
+  return {
+    name: String(name || ''),
+    protocol: '/nexus/invoke/1.1.0',
+    description: String((details && details.description) || 'Omnius capability'),
+    pricing: String((details && details.pricing) || 'free'),
+    rateLimit: String((details && details.rateLimit) || ''),
+  };
+}
+function _rememberCapabilityRecord(record) {
+  if (!record || !record.capability || !record.peerId) return;
+  var all = _readJson(capabilityRecordsFile, {});
+  all[record.capability + ':' + record.peerId] = record;
+  _writeJson(capabilityRecordsFile, all);
+}
+function _rememberSponsorRecord(record) {
+  if (!record) return;
+  var key = record.peerId || record.libp2pPeerId || record.tunnelUrl || record.name;
+  if (!key) return;
+  var all = _readJson(sponsorMeshCacheFile, {});
+  all[key] = Object.assign({}, record, { lastSeen: Date.now() });
+  _writeJson(sponsorMeshCacheFile, all);
+}
+function _readFreshSponsorMeshCache(maxAgeMs) {
+  var all = _readJson(sponsorMeshCacheFile, {});
+  var fresh = [];
+  var changed = false;
+  var now = Date.now();
+  for (var key of Object.keys(all)) {
+    var rec = all[key];
+    var ts = rec.lastSeen || rec.timestamp || 0;
+    if (rec.status === 'active' && now - ts < maxAgeMs) {
+      fresh.push(rec);
+    } else {
+      delete all[key];
+      changed = true;
+    }
+  }
+  if (changed) _writeJson(sponsorMeshCacheFile, all);
+  return fresh;
+}
+function _extractSponsorFromMeshMessage(msg) {
+  var payload = msg && msg.payload ? msg.payload : msg;
+  if (!payload) return null;
+  if (payload.sponsor && payload.sponsor.type === 'sponsor.announce') return payload.sponsor;
+  if (payload.record && payload.record.sponsor && payload.record.sponsor.type === 'sponsor.announce') return payload.record.sponsor;
+  if (payload.record && payload.record.type === 'sponsor.announce') return payload.record;
+  if (payload.type === 'sponsor.announce') return payload;
+  return null;
+}
+async function _publishAgentProfileSnapshot() {
+  try {
+    if (!connected || !nexus.network || !nexus.network.dht || !nexus.network.dht.registry) return;
+    var node = nexus.network.node;
+    var caps = typeof nexus.getRegisteredCapabilities === 'function' ? nexus.getRegisteredCapabilities() : [];
+    var profile = {
+      schema: 'nexus:agent-profile:v1',
+      peerId: nexus.peerId,
+      name: agentName,
+      description: 'Omnius agent node',
+      type: agentType,
+      capabilities: caps.map(function(cap) { return _capabilityDefinition(cap, { description: 'Omnius registered capability' }); }),
+      role: nexusOpts.role || 'full',
+      transports: node && typeof node.getMultiaddrs === 'function' ? node.getMultiaddrs().map(function(a) { return a.toString(); }) : [],
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      previousVersion: null,
+    };
+    await Promise.race([
+      nexus.network.dht.registry.publishProfile(profile),
+      new Promise(function(resolve) { setTimeout(resolve, 2500); }),
+    ]);
+  } catch (err) {
+    dlog('profile publish failed: ' + (err.message || err));
+  }
+}
+async function _publishCapabilityRecord(name, details) {
+  if (!connected) return;
+  var capName = String(name || '');
+  if (!capName) return;
+  var now = Date.now();
+  var peerId = nexus.peerId || '';
+  var record = Object.assign({
+    schema: 'omnius:nexus-capability:v1',
+    capability: capName,
+    peerId: peerId,
+    agentName: agentName,
+    agentType: agentType,
+    protocol: '/nexus/invoke/1.1.0',
+    transport: 'libp2p',
+    status: 'active',
+    timestamp: now,
+    expiresAt: now + 60 * 60 * 1000,
+  }, details || {});
+  _rememberCapabilityRecord(record);
+  if (record.sponsor) _rememberSponsorRecord(record.sponsor);
+
+  try {
+    var proto = await import('open-agents-nexus');
+    var pubsub = nexus.network && nexus.network.node && nexus.network.node.services ? nexus.network.node.services.pubsub : null;
+    if (pubsub && proto.createMessage && proto.encodeMessage && proto.TOPICS) {
+      var capTopic = proto.TOPICS.CAPABILITY_PREFIX + _sanitizeCapabilityKey(capName);
+      var capPayload = {
+        capabilities: [_capabilityDefinition(capName, details || {})],
+        record: record,
+        sponsor: record.sponsor || undefined,
+      };
+      var capMsg = proto.createMessage('capability', capTopic, peerId, capPayload);
+      try { pubsub.subscribe(capTopic); } catch {}
+      await pubsub.publish(capTopic, proto.encodeMessage(capMsg));
+      var metaMsg = proto.createMessage('capability', proto.TOPICS.META, peerId, capPayload);
+      try { pubsub.subscribe(proto.TOPICS.META); } catch {}
+      await pubsub.publish(proto.TOPICS.META, proto.encodeMessage(metaMsg));
+    }
+  } catch (gsErr) {
+    dlog('capability gossip publish failed for ' + capName + ': ' + (gsErr.message || gsErr));
+  }
+
+  try {
+    var dht = nexus.network && nexus.network.node && nexus.network.node.services ? nexus.network.node.services.dht : null;
+    if (!dht) return;
+    var payload = JSON.stringify(record);
+    var valueText = payload;
+    try {
+      var signing = await import('open-agents-nexus/protocol/signing.js');
+      var privateKey = nexus.identity && nexus.identity.privateKey;
+      if (privateKey && signing.signEnvelope) {
+        var seqKey = capName + ':' + peerId;
+        _capabilityPointerSeq[seqKey] = (_capabilityPointerSeq[seqKey] || 0) + 1;
+        var env = await signing.signEnvelope({
+          schema: 'nexus:pointer-envelope:v1',
+          kind: 'capability-pointer',
+          issuer: peerId,
+          cid: payload,
+          seq: _capabilityPointerSeq[seqKey],
+          issuedAt: now,
+          expiresAt: now + 60 * 60 * 1000,
+        }, privateKey);
+        valueText = JSON.stringify(env);
+      }
+    } catch {}
+    var keys = [
+      '/nexus/capability/' + _sanitizeCapabilityKey(capName),
+      '/nexus/capability/' + _sanitizeCapabilityKey(capName) + '/' + peerId,
+    ];
+    for (var ki = 0; ki < keys.length; ki++) {
+      try {
+        await _dhtPutBounded(dht, new TextEncoder().encode(keys[ki]), new TextEncoder().encode(valueText), keys[ki]);
+      } catch (putErr) {
+        dlog('DHT put failed for ' + keys[ki] + ': ' + (putErr.message || putErr));
+      }
+    }
+  } catch (dhtErr) {
+    dlog('capability DHT publish failed for ' + capName + ': ' + (dhtErr.message || dhtErr));
+  }
+  _publishAgentProfileSnapshot().catch(function(err) {
+    dlog('profile snapshot publish failed: ' + (err.message || err));
+  });
+}
+async function _readDhtCapabilityRecord(name) {
+  var out = [];
+  try {
+    var dht = nexus.network && nexus.network.node && nexus.network.node.services ? nexus.network.node.services.dht : null;
+    if (!dht) return out;
+    var key = new TextEncoder().encode('/nexus/capability/' + _sanitizeCapabilityKey(name));
+    for await (var event of dht.get(key)) {
+      if (event.name !== 'VALUE') continue;
+      var parsed = JSON.parse(new TextDecoder().decode(event.value));
+      if (parsed && parsed.schema === 'nexus:pointer-envelope:v1' && parsed.cid) {
+        out.push(JSON.parse(parsed.cid));
+      } else {
+        out.push(parsed);
+      }
+    }
+  } catch (err) {
+    dlog('DHT capability read failed for ' + name + ': ' + (err.message || err));
+  }
+  return out;
+}
+function _installMeshDiscoveryHandlers() {
+  if (_meshDiscoveryInstalled) return;
+  try {
+    var pubsub = nexus.network && nexus.network.node && nexus.network.node.services ? nexus.network.node.services.pubsub : null;
+    if (!pubsub) return;
+    _meshDiscoveryInstalled = true;
+    var topics = ['/nexus/meta', '/nexus/capability/sponsor_inference'];
+    for (var ti = 0; ti < topics.length; ti++) {
+      try { pubsub.subscribe(topics[ti]); } catch {}
+    }
+    pubsub.addEventListener('message', function(evt) {
+      try {
+        var detail = evt && evt.detail ? evt.detail : null;
+        if (!detail || topics.indexOf(detail.topic) === -1) return;
+        var msg = JSON.parse(new TextDecoder().decode(detail.data));
+        var sponsor = _extractSponsorFromMeshMessage(msg);
+        if (sponsor) _rememberSponsorRecord(sponsor);
+        var rec = msg && msg.payload && msg.payload.record ? msg.payload.record : null;
+        if (rec && rec.capability) _rememberCapabilityRecord(rec);
+      } catch {}
+    });
+    dlog('mesh discovery handlers installed for ' + topics.join(','));
+  } catch (err) {
+    dlog('mesh discovery handler install failed: ' + (err.message || err));
+  }
+}
+
 // Collect CPU/GPU/memory metrics for piggybacking on inference responses.
 // Avoids separate invoke_capability round-trip that clogs the IPC.
 var _sysMetricsCache = null;
@@ -12427,7 +12708,16 @@ async function handleCmd(cmd) {
         } catch (gsErr) {
           dlog('sponsor_announce: GossipSub meta failed: ' + (gsErr.message || gsErr));
         }
-        writeResp(id, { ok: true, output: 'Sponsor announced: ' + sponsorData.name + ' (' + sponsorData.models.length + ' models) [NATS+KV+Room+GossipSub]' });
+        _rememberSponsorRecord(sponsorData);
+        await _publishCapabilityRecord('sponsor_inference', {
+          description: 'Sponsored Omnius inference via ' + sponsorData.name,
+          pricing: 'sponsored',
+          rateLimit: String(sponsorData.limits.maxRequestsPerMinute) + '/min',
+          sponsor: sponsorData,
+          models: sponsorData.models,
+          limits: sponsorData.limits,
+        });
+        writeResp(id, { ok: true, output: 'Sponsor announced: ' + sponsorData.name + ' (' + sponsorData.models.length + ' models) [DHT+GossipSub+NATS+KV+Room]' });
         break;
       }
       // NX-05 + NX-06: Register sponsor_inference capability for P2P inference relay.
@@ -12488,6 +12778,12 @@ async function handleCmd(cmd) {
             stream.write({ type: 'invoke.error', error: String(rsiErr.message || rsiErr) });
           }
         });
+        await _publishCapabilityRecord('sponsor_inference', {
+          description: 'Sponsored Omnius inference relay',
+          pricing: 'sponsored',
+          rateLimit: 'sponsor-policy',
+          models: _rsiAllowedModels || [],
+        });
         writeResp(id, { ok: true, output: 'Registered sponsor_inference capability (P2P relay active)' });
         break;
       }
@@ -12517,7 +12813,31 @@ async function handleCmd(cmd) {
           dlog('sponsor_discover: KV fetch failed: ' + (kvErr.message || kvErr));
         }
 
-        // ── Source 2: NATS live announcements (if connected) ──
+        // ── Source 2: Nexus mesh cache + DHT capability pointer ──
+        try {
+          var meshSponsors = _readFreshSponsorMeshCache(10 * 60 * 1000);
+          for (var mi = 0; mi < meshSponsors.length; mi++) foundSponsors.push(meshSponsors[mi]);
+          dlog('sponsor_discover: mesh cache returned ' + meshSponsors.length + ' sponsor(s)');
+        } catch (meshErr) {
+          dlog('sponsor_discover: mesh cache failed: ' + (meshErr.message || meshErr));
+        }
+        try {
+          var dhtCaps = await _readDhtCapabilityRecord('sponsor_inference');
+          var dhtCount = 0;
+          for (var di = 0; di < dhtCaps.length; di++) {
+            var capRec = dhtCaps[di];
+            var spRec = capRec && capRec.sponsor ? capRec.sponsor : null;
+            if (spRec && spRec.status === 'active') {
+              foundSponsors.push(spRec);
+              dhtCount++;
+            }
+          }
+          dlog('sponsor_discover: DHT sponsor_inference returned ' + dhtCount + ' sponsor(s)');
+        } catch (dhtDiscErr) {
+          dlog('sponsor_discover: DHT sponsor read failed: ' + (dhtDiscErr.message || dhtDiscErr));
+        }
+
+        // ── Source 3: NATS live announcements (if connected) ──
         if (_natsConn && _natsCodec) {
 
         // Also check sponsors room inbox for cached messages
@@ -13067,7 +13387,12 @@ async function handleCmd(cmd) {
           stream.close();
         });
         writeStatus();
-        writeResp(id, { ok: true, output: 'Capability registered: ' + name + '. Now advertised via NATS.' });
+        await _publishCapabilityRecord(name, {
+          description: String(args.description || 'Omnius registered capability'),
+          pricing: String(args.pricing || 'free'),
+          rateLimit: String(args.rate_limit || ''),
+        });
+        writeResp(id, { ok: true, output: 'Capability registered: ' + name + '. Advertised via DHT/GossipSub/NATS.' });
         break;
       }
       case 'unregister_capability': {
@@ -14067,6 +14392,23 @@ async function handleCmd(cmd) {
           }
         }
 
+        for (var pci = 0; pci < pricingMenu.length; pci++) {
+          var capPricing = pricingMenu[pci];
+          await _publishCapabilityRecord('inference:' + capPricing.model.replace(/[^a-zA-Z0-9._-]/g, '_'), {
+            description: 'Omnius inference model ' + capPricing.model,
+            pricing: capPricing.pricing && capPricing.pricing.input_per_1m_tokens === 0
+              ? 'free'
+              : JSON.stringify(capPricing.pricing || {}),
+            rateLimit: _sponsorLimits
+              ? String(_sponsorLimits.maxRequestsPerMinute) + '/min'
+              : 'provider-policy',
+            model: capPricing.model,
+            modelDetails: capPricing,
+            passthrough: isPassthrough,
+            limits: _sponsorLimits,
+          });
+        }
+
         // Register system_metrics capability — returns CPU/GPU/memory utilization
         if (typeof nexus.registerCapability === 'function') {
           nexus.registerCapability('system_metrics', async (request, stream) => {
@@ -14174,6 +14516,11 @@ async function handleCmd(cmd) {
             try { stream.close(); } catch {}
           });
           dlog('system_metrics capability registered');
+          await _publishCapabilityRecord('system_metrics', {
+            description: 'Provider CPU/GPU/RAM/disk and sponsor gateway metrics',
+            pricing: 'free',
+            rateLimit: 'provider-policy',
+          });
         }
 
         // Register __list_capabilities — allows remote peers to discover available models
@@ -14198,6 +14545,19 @@ async function handleCmd(cmd) {
             stream.close();
           });
           dlog('__list_capabilities capability registered');
+          await _publishCapabilityRecord('__list_capabilities', {
+            description: 'Live provider capability and model list',
+            pricing: 'free',
+            rateLimit: 'provider-policy',
+            models: pricingMenu.map(function(pm) {
+              return {
+                name: pm.model,
+                parameterSize: pm.parameterSize || '',
+                family: pm.family || '',
+                quantization: pm.quantization || '',
+              };
+            }),
+          });
         }
 
         // Write pricing menu to file
@@ -14469,6 +14829,8 @@ process.on('unhandledRejection', (reason) => {
       await node.start();
     }
     connected = true;
+    _installMeshDiscoveryHandlers();
+    await _publishAgentProfileSnapshot();
 
     // Register this nexus dir in the global registry so the API daemon
     // (and any other consumer) can discover us regardless of cwd.
@@ -14620,6 +14982,11 @@ process.on('unhandledRejection', (reason) => {
         try { stream.close(); } catch {}
       });
       dlog('http_tunnel capability registered (api hint: ' + apiPortHintPath + ')');
+      await _publishCapabilityRecord('http_tunnel', {
+        description: 'Omnius API HTTP tunnel over direct Nexus invoke streams',
+        pricing: 'share-key',
+        rateLimit: 'api-policy',
+      });
     }
 
     // Monkey-patch node.dialProtocol AND node.dial to convert string multiaddrs
@@ -17495,6 +17862,17 @@ ${earlyError ? "\n" + earlyError : ""}${earlyOutput ? "\n" + earlyOutput : ""}`;
             `  Capabilities: ${(status.capabilities || []).length ? (status.capabilities || []).join(", ") : "none"}`,
             `  Blocked peers: ${(status.blockedPeers || []).length || 0}`
           ];
+          if (status.networkStack) {
+            const ns = status.networkStack;
+            const disc = ns.discovery || {};
+            const enabled2 = Object.entries(disc).filter(([, value2]) => value2 === true).map(([key]) => key).join(", ");
+            lines.push(`  Network role: ${ns.role || "full"}`);
+            lines.push(`  Discovery: ${enabled2 || "none"}`);
+            lines.push(`  Signaling: ${ns.signalingServer || "n/a"}`);
+            if (Array.isArray(ns.manifestUrls) && ns.manifestUrls.length > 0) {
+              lines.push(`  Bootstrap manifests: ${ns.manifestUrls.length}`);
+            }
+          }
           const walletPath = join23(this.nexusDir, "wallet.enc");
           if (existsSync21(walletPath)) {
             try {
@@ -581489,23 +581867,57 @@ ${CONTENT_BG_SEQ}`);
         const w = termWidth ?? getTermWidth();
         return Math.max(1, w - this.promptWidth - 2);
       }
+      wrapPlainInputText(text, availWidth) {
+        const width = Math.max(1, availWidth);
+        const rawLines = [];
+        const charPositions = [];
+        const pushWrappedSegment = (segment, segmentStart2) => {
+          if (segment.length === 0) {
+            charPositions.push(segmentStart2);
+            rawLines.push("");
+            return;
+          }
+          let offset = 0;
+          while (offset < segment.length) {
+            const remaining = segment.slice(offset);
+            if (remaining.length <= width) {
+              charPositions.push(segmentStart2 + offset);
+              rawLines.push(remaining);
+              break;
+            }
+            let breakAt = width;
+            const lastSpace = remaining.lastIndexOf(" ", width);
+            if (lastSpace > 0 && lastSpace >= width * 0.3) {
+              breakAt = lastSpace + 1;
+            }
+            charPositions.push(segmentStart2 + offset);
+            rawLines.push(remaining.slice(0, breakAt));
+            offset += breakAt;
+          }
+        };
+        if (text.length === 0) {
+          pushWrappedSegment("", 0);
+          return { rawLines, charPositions };
+        }
+        let segmentStart = 0;
+        while (segmentStart <= text.length) {
+          const newlineAt = text.indexOf("\n", segmentStart);
+          const segmentEnd = newlineAt === -1 ? text.length : newlineAt;
+          pushWrappedSegment(text.slice(segmentStart, segmentEnd), segmentStart);
+          if (newlineAt === -1) break;
+          segmentStart = newlineAt + 1;
+          if (segmentStart === text.length) {
+            pushWrappedSegment("", segmentStart);
+            break;
+          }
+        }
+        return { rawLines, charPositions };
+      }
       computeInputLineCount(termWidth) {
         if (!this.inputStateProvider) return 1;
         const availWidth = this.inputTextWidth(termWidth);
         const { line } = this.inputStateProvider();
-        if (line.length <= availWidth) return 1;
-        let count = 0;
-        let remaining = line;
-        while (remaining.length > 0) {
-          count++;
-          if (remaining.length <= availWidth) break;
-          let breakAt = availWidth;
-          const lastSpace = remaining.lastIndexOf(" ", availWidth);
-          if (lastSpace > 0 && lastSpace >= availWidth * 0.3)
-            breakAt = lastSpace + 1;
-          remaining = remaining.slice(breakAt);
-        }
-        return Math.max(1, count);
+        return Math.max(1, this.wrapPlainInputText(line, availWidth).rawLines.length);
       }
       /** Update _currentFooterHeight based on current input + suggestions. Returns true if height changed. */
       updateFooterHeight(termWidth) {
@@ -581565,8 +581977,9 @@ ${CONTENT_BG_SEQ}`);
         const inputState = this.inputStateProvider?.();
         const fullLine = inputState?.line ?? "";
         const cursorPos = inputState?.cursor ?? 0;
+        const hasExplicitLineBreak = fullLine.includes("\n");
         const ghost = this.getGhostText(fullLine, cursorPos);
-        if (fullLine.length <= availWidth) {
+        if (!hasExplicitLineBreak && fullLine.length <= availWidth) {
           let displayLine;
           if (ghost) {
             displayLine = fullLine + `\x1B[7m\x1B[38;5;${TEXT_DIM}m${ghost[0]}\x1B[0m${PANEL_BG_SEQ}\x1B[38;5;${TEXT_DIM}m${ghost.slice(1)}\x1B[0m${PANEL_BG_SEQ}`;
@@ -581581,28 +581994,7 @@ ${CONTENT_BG_SEQ}`);
             cursorCol: Math.min(Math.max(1, termWidth - 1), this.promptWidth + cursorPos + 2)
           };
         }
-        const rawLines = [];
-        let remaining = fullLine;
-        const charPositions = [];
-        while (remaining.length > 0) {
-          if (remaining.length <= availWidth) {
-            charPositions.push(fullLine.length - remaining.length);
-            rawLines.push(remaining);
-            break;
-          }
-          let breakAt = availWidth;
-          const lastSpace = remaining.lastIndexOf(" ", availWidth);
-          if (lastSpace > 0 && lastSpace >= availWidth * 0.3) {
-            breakAt = lastSpace + 1;
-          }
-          charPositions.push(fullLine.length - remaining.length);
-          rawLines.push(remaining.slice(0, breakAt));
-          remaining = remaining.slice(breakAt);
-        }
-        if (rawLines.length === 0) {
-          rawLines.push("");
-          charPositions.push(0);
-        }
+        const { rawLines, charPositions } = this.wrapPlainInputText(fullLine, availWidth);
         let cursorLineIdx = rawLines.length - 1;
         let cursorColInLine = cursorPos;
         for (let i2 = 0; i2 < charPositions.length; i2++) {
@@ -633486,27 +633878,48 @@ var init_direct_input = __esm({
        * and rawLines (text of each line). Matches wrapInput logic in status-bar.ts.
        */
       _computeWrappedLines(availWidth) {
+        const width = Math.max(1, availWidth);
         const rawLines = [];
         const charPositions = [];
-        let remaining = this.line;
-        while (remaining.length > 0) {
-          if (remaining.length <= availWidth) {
-            charPositions.push(this.line.length - remaining.length);
-            rawLines.push(remaining);
-            break;
+        const pushWrappedSegment = (segment, segmentStart2) => {
+          if (segment.length === 0) {
+            charPositions.push(segmentStart2);
+            rawLines.push("");
+            return;
           }
-          let breakAt = availWidth;
-          const lastSpace = remaining.lastIndexOf(" ", availWidth);
-          if (lastSpace > 0 && lastSpace >= availWidth * 0.3) {
-            breakAt = lastSpace + 1;
+          let offset = 0;
+          while (offset < segment.length) {
+            const remaining = segment.slice(offset);
+            if (remaining.length <= width) {
+              charPositions.push(segmentStart2 + offset);
+              rawLines.push(remaining);
+              break;
+            }
+            let breakAt = width;
+            const lastSpace = remaining.lastIndexOf(" ", width);
+            if (lastSpace > 0 && lastSpace >= width * 0.3) {
+              breakAt = lastSpace + 1;
+            }
+            charPositions.push(segmentStart2 + offset);
+            rawLines.push(remaining.slice(0, breakAt));
+            offset += breakAt;
+          }
+        };
+        if (this.line.length === 0) {
+          pushWrappedSegment("", 0);
+          return { charPositions, rawLines };
+        }
+        let segmentStart = 0;
+        while (segmentStart <= this.line.length) {
+          const newlineAt = this.line.indexOf("\n", segmentStart);
+          const segmentEnd = newlineAt === -1 ? this.line.length : newlineAt;
+          pushWrappedSegment(this.line.slice(segmentStart, segmentEnd), segmentStart);
+          if (newlineAt === -1) break;
+          segmentStart = newlineAt + 1;
+          if (segmentStart === this.line.length) {
+            pushWrappedSegment("", segmentStart);
+            break;
           }
-          charPositions.push(this.line.length - remaining.length);
-          rawLines.push(remaining.slice(0, breakAt));
-          remaining = remaining.slice(breakAt);
-        }
-        if (rawLines.length === 0) {
-          rawLines.push("");
-          charPositions.push(0);
         }
         return { charPositions, rawLines };
       }
@@ -633692,6 +634105,10 @@ var init_direct_input = __esm({
             this.cursor = this.line.length;
             return;
           case "~":
+            if (this._isShiftEnterCSI(params)) {
+              this._insertText("\n");
+              return;
+            }
             if (params === "3") {
               if (this.cursor < this.line.length) {
                 this.line = this.line.slice(0, this.cursor) + this.line.slice(this.cursor + 1);
@@ -633713,6 +634130,10 @@ var init_direct_input = __esm({
             const modifiers = parseInt(parts[1] ?? "1");
             const hasCtrl = modifiers - 1 & 4;
             const hasShift = modifiers - 1 & 1;
+            if (hasShift && (codepoint === 10 || codepoint === 13)) {
+              this._insertText("\n");
+              return;
+            }
             if (hasCtrl && hasShift) {
               if (codepoint === 67) {
                 this.emit("ctrl-shift-c");
@@ -633731,6 +634152,22 @@ var init_direct_input = __esm({
           }
         }
       }
+      _isShiftEnterCSI(params) {
+        const parts = params.split(";").map((part) => parseInt(part, 10));
+        if (parts.length === 2) {
+          const [codepoint, modifiers] = parts;
+          return (codepoint === 10 || codepoint === 13) && modifiers === 2;
+        }
+        if (parts.length === 3) {
+          const [prefix, modifiers, codepoint] = parts;
+          return prefix === 27 && modifiers === 2 && (codepoint === 10 || codepoint === 13);
+        }
+        return false;
+      }
+      _insertText(text) {
+        this.line = this.line.slice(0, this.cursor) + text + this.line.slice(this.cursor);
+        this.cursor += text.length;
+      }
       /** Handle SS3 sequence: \x1BO {final} (some terminals use this for arrows/Home/End) */
       _handleSS3(final2) {
         switch (final2) {

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.150",
+  "version": "1.0.152",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.150",
+      "version": "1.0.152",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.150",
+  "version": "1.0.152",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/index.js",