omnius 1.0.38 → 1.0.39

package/dist/index.js

@@ -16256,6 +16256,180 @@ function loadSkillContent(skillPath) {
     return null;
   }
 }
+function tokenizeSkillQuery(value2) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of value2.toLowerCase().match(/[a-z0-9_.-]{3,}/g) ?? []) {
+    const token = raw.replace(/^[_.-]+|[_.-]+$/g, "");
+    if (token.length < 3 || SKILL_STOPWORDS.has(token) || seen.has(token))
+      continue;
+    seen.add(token);
+    out.push(token);
+    if (out.length >= 24)
+      break;
+  }
+  return out;
+}
+function compactSkillLine(value2, max = 180) {
+  const clean3 = value2.replace(/\s+/g, " ").trim();
+  return clean3.length > max ? `${clean3.slice(0, Math.max(0, max - 3)).trimEnd()}...` : clean3;
+}
+function skillHaystack(skill) {
+  return [
+    skill.name,
+    skill.name.replace(/[-_]/g, " "),
+    skill.description,
+    skill.source,
+    ...skill.triggers
+  ].join(" ").toLowerCase();
+}
+function scoreSkill(skill, terms) {
+  if (terms.length === 0)
+    return null;
+  const hay = skillHaystack(skill);
+  const matched = [];
+  let score = 0;
+  for (const term of terms) {
+    if (!hay.includes(term))
+      continue;
+    matched.push(term);
+    if (skill.name.toLowerCase().includes(term))
+      score += 5;
+    if (skill.triggers.some((trigger) => trigger.toLowerCase().includes(term)))
+      score += 3;
+    if (skill.description.toLowerCase().includes(term))
+      score += 2;
+    if (skill.source.toLowerCase().includes(term))
+      score += 1;
+  }
+  if (score <= 0)
+    return null;
+  return {
+    skill,
+    score,
+    matchedTerms: matched.slice(0, 8),
+    reason: matched.length ? `matched: ${matched.slice(0, 6).join(", ")}` : "selected by task overlap"
+  };
+}
+function selectSkillsForTask(skills, task, limit = 4) {
+  const terms = tokenizeSkillQuery(task);
+  return skills.map((skill) => scoreSkill(skill, terms)).filter((item) => Boolean(item)).sort((a2, b) => b.score - a2.score || a2.skill.name.localeCompare(b.skill.name)).slice(0, Math.max(0, limit));
+}
+function buildEphemeralSkillPack(skills, opts) {
+  const tier = opts.modelTier ?? "large";
+  const defaultLimit = tier === "small" ? 3 : tier === "medium" ? 4 : 5;
+  const selected = selectSkillsForTask(skills, opts.task, opts.limit ?? defaultLimit);
+  if (selected.length === 0)
+    return "";
+  const lines = [
+    "<ephemeral-skill-pack>",
+    "Scope: current task run only. Discard after this run; do not write this segment to memory or handoff artifacts.",
+    "Purpose: expose only a tiny manifest of likely-relevant skills. Do not load full SKILL.md content into the main context unless necessary.",
+    "Small-context protocol: if a skill applies, call skill_extract with the current task/query. Prefer use_subagent=true so a delegated worker reads the full skill and returns only targeted guidance.",
+    "Authority: workflow guidance only; user/system/developer instructions and tool policy remain higher priority.",
+    "Selected skills:"
+  ];
+  for (const item of selected) {
+    const skill = item.skill;
+    const trigger = skill.triggers[0] ? ` trigger="${compactSkillLine(skill.triggers[0], 80)}"` : "";
+    lines.push(`- ${skill.name} [${skill.source}] score=${item.score}${trigger}: ${compactSkillLine(skill.description || "(no description)", 140)} (${item.reason})`);
+  }
+  lines.push("</ephemeral-skill-pack>");
+  return lines.join("\n");
+}
+function splitSkillSections(content) {
+  const lines = content.split("\n");
+  const sections = [];
+  let currentTitle = "Frontmatter and Overview";
+  let current = [];
+  for (const line of lines) {
+    const heading = line.match(/^(#{1,4})\s+(.+?)\s*$/);
+    if (heading) {
+      if (current.join("\n").trim()) {
+        const body = current.join("\n").trim();
+        sections.push({ title: currentTitle, body, text: `${currentTitle}
+${body}` });
+      }
+      currentTitle = heading[2].trim();
+      current = [];
+      continue;
+    }
+    current.push(line);
+  }
+  if (current.join("\n").trim()) {
+    const body = current.join("\n").trim();
+    sections.push({ title: currentTitle, body, text: `${currentTitle}
+${body}` });
+  }
+  return sections;
+}
+function sectionScore(section, terms) {
+  const hay = section.text.toLowerCase();
+  let score = 0;
+  for (const term of terms) {
+    if (!hay.includes(term))
+      continue;
+    score += section.title.toLowerCase().includes(term) ? 4 : 1;
+  }
+  if (/\b(workflow|procedure|steps|how to use|usage|required|output|deliverable|verification|checklist|safety|pitfall|anti-pattern)\b/i.test(section.title)) {
+    score += 2;
+  }
+  return score;
+}
+function bulletizeLines(value2, maxLines, maxChars) {
+  const out = [];
+  for (const raw of value2.split("\n")) {
+    const line = raw.replace(/^[-*]\s+/, "").trim();
+    if (!line || /^---+$/.test(line) || /^```/.test(line))
+      continue;
+    if (/^#+\s/.test(line))
+      continue;
+    out.push(`- ${compactSkillLine(line, maxChars)}`);
+    if (out.length >= maxLines)
+      break;
+  }
+  return out;
+}
+function capSkillExtractionOutput(value2, budgetTokens) {
+  const maxChars = Math.max(1200, Math.min(7e3, budgetTokens * 4));
+  if (value2.length <= maxChars)
+    return value2;
+  return `${value2.slice(0, Math.max(0, maxChars - 90)).trimEnd()}
+
+[skill extraction truncated to ${budgetTokens} token budget]`;
+}
+function extractSkillForQuery(skill, content, query, budgetTokens = 900) {
+  const terms = tokenizeSkillQuery(`${query} ${skill.name} ${skill.description} ${skill.triggers.join(" ")}`);
+  const sections = splitSkillSections(content).map((section) => ({ ...section, score: sectionScore(section, terms) })).sort((a2, b) => b.score - a2.score || a2.title.localeCompare(b.title));
+  const selectedSections = sections.filter((section) => section.score > 0).slice(0, 4);
+  const fallbackSections = selectedSections.length ? selectedSections : sections.slice(0, 3);
+  const maxChars = Math.max(1200, Math.min(6e3, budgetTokens * 4));
+  const lines = [
+    `<skill-extraction name="${skill.name}" source="${skill.source}">`,
+    `Query: ${compactSkillLine(query, 240)}`,
+    `Purpose: targeted operational guidance only; discard after current run.`,
+    `Use when: ${compactSkillLine(skill.description || skill.triggers[0] || skill.name, 220)}`
+  ];
+  if (skill.triggers.length > 0)
+    lines.push(`Triggers: ${skill.triggers.slice(0, 4).map((t2) => compactSkillLine(t2, 80)).join(" | ")}`);
+  if (skill.compactionStrategy)
+    lines.push(`Compaction: ${skill.compactionStrategy}`);
+  if (skill.provenance)
+    lines.push(`Provenance: ${formatProvenanceSummary(skill.provenance)}`);
+  lines.push("Relevant guidance:");
+  for (const section of fallbackSections) {
+    lines.push(`Section: ${compactSkillLine(section.title, 100)}`);
+    lines.push(...bulletizeLines(section.body, 6, 170));
+    if (lines.join("\n").length > maxChars)
+      break;
+  }
+  lines.push("Parent instruction: use the extracted guidance if relevant; otherwise ignore it. Do not ask to load the full skill unless this extraction is insufficient.");
+  lines.push("</skill-extraction>");
+  const out = lines.join("\n");
+  return out.length > maxChars ? `${out.slice(0, Math.max(0, maxChars - 80)).trimEnd()}
+- [truncated to extraction budget]
+</skill-extraction>` : out;
+}
 function buildSkillsSummary(skills) {
   if (skills.length === 0)
     return "";
@@ -16457,11 +16631,61 @@ function parseTriggers(filePath) {
   }
   return triggers;
 }
-var _cachedAiwgPkgRoot, SkillListTool, SkillExecuteTool;
+var _cachedAiwgPkgRoot, SKILL_STOPWORDS, SkillListTool, SkillExecuteTool, SkillExtractTool;
 var init_skill_tools = __esm({
   "packages/execution/dist/tools/skill-tools.js"() {
     "use strict";
     init_provenance();
+    SKILL_STOPWORDS = /* @__PURE__ */ new Set([
+      "about",
+      "after",
+      "again",
+      "also",
+      "and",
+      "are",
+      "because",
+      "been",
+      "but",
+      "can",
+      "code",
+      "could",
+      "does",
+      "done",
+      "for",
+      "from",
+      "have",
+      "how",
+      "into",
+      "just",
+      "more",
+      "need",
+      "not",
+      "now",
+      "our",
+      "out",
+      "please",
+      "project",
+      "repo",
+      "run",
+      "should",
+      "task",
+      "that",
+      "the",
+      "their",
+      "then",
+      "there",
+      "this",
+      "tool",
+      "use",
+      "was",
+      "what",
+      "when",
+      "where",
+      "with",
+      "work",
+      "you",
+      "your"
+    ]);
     SkillListTool = class {
       name = "skill_list";
       description = "List all available AIWG skills with their descriptions and trigger patterns. Use this to discover skills that can help with the current task.";
@@ -16605,6 +16829,131 @@ ${content}`,
         };
       }
     };
+    SkillExtractTool = class {
+      name = "skill_extract";
+      description = "Extract targeted, task-specific guidance from one or more AIWG skills without loading full skill bodies into the main context. Use this before skill_execute on small/medium context windows. Prefer use_subagent=true for large or complex skills.";
+      parameters = {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "Current task or precise extraction question."
+          },
+          name: {
+            type: "string",
+            description: "Optional exact skill name. If omitted, relevant skills are selected from query overlap."
+          },
+          filter: {
+            type: "string",
+            description: "Optional additional skill filter by name, description, trigger, or source."
+          },
+          limit: {
+            type: "number",
+            description: "Maximum skills to extract. Defaults to 2, max 5."
+          },
+          budget_tokens: {
+            type: "number",
+            description: "Approximate output budget per skill. Defaults to 900, max 1600."
+          },
+          use_subagent: {
+            type: "boolean",
+            description: "Delegate full SKILL.md reading to a sub-agent and return only its compact extraction. Defaults to true when available."
+          }
+        },
+        required: ["query"]
+      };
+      repoRoot;
+      _extractCallback;
+      constructor(repoRoot) {
+        this.repoRoot = repoRoot;
+      }
+      setExtractCallback(cb) {
+        this._extractCallback = cb;
+      }
+      async execute(args) {
+        const start2 = performance.now();
+        const query = String(args["query"] ?? args["task"] ?? args["prompt"] ?? "").trim();
+        if (!query) {
+          return {
+            success: false,
+            output: "",
+            error: "query is required. Pass the current task or precise extraction question.",
+            durationMs: performance.now() - start2
+          };
+        }
+        const name10 = String(args["name"] ?? args["skill_name"] ?? args["skill"] ?? "").trim();
+        const filter2 = String(args["filter"] ?? args["source"] ?? "").trim().toLowerCase();
+        const limitRaw = typeof args["limit"] === "number" ? args["limit"] : 2;
+        const limit = Math.max(1, Math.min(5, Math.floor(limitRaw)));
+        const budgetRaw = typeof args["budget_tokens"] === "number" ? args["budget_tokens"] : 900;
+        const budgetTokens = Math.max(300, Math.min(1600, Math.floor(budgetRaw)));
+        const useSubagent = args["use_subagent"] !== false;
+        let skills = discoverSkills(this.repoRoot);
+        if (filter2) {
+          skills = skills.filter((skill) => skillHaystack(skill).includes(filter2));
+        }
+        let selected = [];
+        if (name10) {
+          const exact = skills.find((skill) => skill.name === name10);
+          const fuzzy = exact ? exact : skills.find((skill) => skill.name.includes(name10) || name10.includes(skill.name));
+          if (!fuzzy) {
+            return {
+              success: false,
+              output: "",
+              error: `Skill "${name10}" not found. Use skill_list to discover available skills.`,
+              durationMs: performance.now() - start2
+            };
+          }
+          selected = [{ skill: fuzzy, score: 999, matchedTerms: [name10], reason: "explicit skill name" }];
+        } else {
+          selected = selectSkillsForTask(skills, query, limit);
+        }
+        if (selected.length === 0) {
+          return {
+            success: true,
+            output: `No relevant skills found for query: ${query}`,
+            durationMs: performance.now() - start2
+          };
+        }
+        const outputs = [];
+        for (const item of selected.slice(0, limit)) {
+          const content = loadSkillContent(item.skill.filePath);
+          if (!content) {
+            outputs.push(`<skill-extraction name="${item.skill.name}">
+Error: could not read skill file.
+</skill-extraction>`);
+            continue;
+          }
+          if (useSubagent && this._extractCallback) {
+            try {
+              const extracted = await this._extractCallback(item.skill.name, content, query, budgetTokens);
+              outputs.push(capSkillExtractionOutput(extracted, budgetTokens));
+              continue;
+            } catch (err) {
+              outputs.push(`<skill-extraction name="${item.skill.name}">
+Sub-agent extraction failed: ${err instanceof Error ? err.message : String(err)}
+Fallback:
+${extractSkillForQuery(item.skill, content, query, budgetTokens)}
+</skill-extraction>`);
+              continue;
+            }
+          }
+          outputs.push(extractSkillForQuery(item.skill, content, query, budgetTokens));
+        }
+        const output = [
+          "# Ephemeral Skill Extraction",
+          "Scope: current task only. Do not persist this block to memory unless the user explicitly asks for a durable procedure.",
+          "",
+          ...outputs
+        ].join("\n\n");
+        return {
+          success: true,
+          output,
+          llmContent: output,
+          durationMs: performance.now() - start2
+        };
+      }
+    };
   }
 });
 
@@ -517506,6 +517855,7 @@ __export(dist_exports, {
   ShellTool: () => ShellTool,
   SkillBuildTool: () => SkillBuildTool,
   SkillExecuteTool: () => SkillExecuteTool,
+  SkillExtractTool: () => SkillExtractTool,
   SkillListTool: () => SkillListTool,
   SoundPlaybackTool: () => SoundPlaybackTool,
   StdioTransport: () => StdioTransport,
@@ -517540,6 +517890,7 @@ __export(dist_exports, {
   audioOutputDir: () => audioOutputDir,
   buildCompactDiff: () => buildCompactDiff,
   buildCustomTools: () => buildCustomTools,
+  buildEphemeralSkillPack: () => buildEphemeralSkillPack,
   buildGeneratedArtifactProvenance: () => buildGeneratedArtifactProvenance,
   buildGraph: () => buildGraph,
   buildMcpToolName: () => buildMcpToolName,
@@ -517577,6 +517928,7 @@ __export(dist_exports, {
   ensureAllDesktopDeps: () => ensureAllDesktopDeps,
   ensureCommand: () => ensureCommand,
   ensureDepsForGroup: () => ensureDepsForGroup,
+  extractSkillForQuery: () => extractSkillForQuery,
   flattenSlug: () => flattenSlug,
   formatMessagesForContext: () => formatMessagesForContext,
   formatProvenanceSummary: () => formatProvenanceSummary,
@@ -517657,6 +518009,7 @@ __export(dist_exports, {
   saveMcpServerToConfig: () => saveMcpServerToConfig,
   savePacket: () => savePacket,
   sdcppVenvDir: () => sdcppVenvDir,
+  selectSkillsForTask: () => selectSkillsForTask,
   serializeMap: () => serializeMap,
   setChangeLogSession: () => setChangeLogSession,
   setSudoPassword: () => setSudoPassword,
@@ -533285,7 +533638,7 @@ var init_agenticRunner = __esm({
       ],
       shell: ["shell", "shell_async", "kill_proc", "run_tests"],
       graph: ["graph_query", "graph_traverse", "code_graph"],
-      skill: ["skill_list", "skill_execute", "skill_search"]
+      skill: ["skill_list", "skill_extract", "skill_execute", "skill_search"]
     };
     TOOL_AUTO_DEMOTE_TURNS = 10;
     SYSTEM_PROMPT = loadPrompt("agentic/system-large.md");
@@ -556652,6 +557005,9 @@ var init_render = __esm({
       "aiwg_setup",
       "aiwg_health",
       "aiwg_workflow",
+      "skill_list",
+      "skill_extract",
+      "skill_execute",
       "create_tool",
       "manage_tools",
       "ask_user",
@@ -564385,6 +564741,7 @@ var init_status_bar = __esm({
       desktop_describe: 10,
       code_sandbox: 45,
       skill_list: 5,
+      skill_extract: 20,
       skill_execute: 30,
       create_tool: 120,
       manage_tools: 15,
@@ -600326,6 +600683,230 @@ function buildReplyOpportunities(input, openQuestions) {
   }
   return opportunities;
 }
+function clamp017(value2) {
+  if (!Number.isFinite(value2)) return 0;
+  return Math.max(0, Math.min(1, value2));
+}
+function messageLabel(entry) {
+  return entry.speaker || entry.username || "user";
+}
+function pushStimulationSignal(signals, signal, source, weight) {
+  const cleanSignal = compactLine2(signal, 120);
+  const cleanSource = compactLine2(source, 180);
+  if (!cleanSignal || signals.some((entry) => entry.signal === cleanSignal && entry.source === cleanSource)) return;
+  signals.push({ signal: cleanSignal, source: cleanSource, weight: clamp017(weight) });
+}
+function buildMetaAnalysisSignals(input) {
+  const chatLabel = input.chatTitle || input.chatId;
+  return [
+    `Private meta-analysis for Telegram ${input.chatType} ${chatLabel}; not a visible reply and not a user command.`,
+    "Treat this artifact as a context-management packet: relationship map, curiosity queue, scoped tools, and outreach options.",
+    "Any public or private follow-up still requires a live model decision in the current conversation state.",
+    "Private DM follow-up is a planned affordance only unless a delivery policy and user/contact permission allow it."
+  ];
+}
+function buildHumanStimulationSignals(input) {
+  const signals = [];
+  const recent = recentUserMessages(input);
+  const participants = topParticipants(input);
+  const last2 = recent[recent.length - 1];
+  if (input.stimulationContext) {
+    pushStimulationSignal(signals, "idle stimulation snapshot available", input.stimulationContext.split("\n").slice(0, 2).join(" / "), 0.42);
+  }
+  if (participants.length > 1) {
+    pushStimulationSignal(signals, "multi-person social context", `${participants.length} active participant profiles`, 0.58);
+  }
+  for (const participant of participants.slice(0, 5)) {
+    if (participant.directAddressCount > 0) {
+      pushStimulationSignal(signals, "direct agent address history", `${participant.username || participant.firstName}: ${participant.directAddressCount} direct address(es)`, 0.74);
+    }
+    if (participant.replyCount > 0) {
+      pushStimulationSignal(signals, "reply-chain salience", `${participant.username || participant.firstName}: ${participant.replyCount} reply relationship(s)`, 0.68);
+    }
+    if (participant.toneTags.includes("frustrated") || participant.toneTags.includes("technical")) {
+      pushStimulationSignal(signals, "high-specificity user state", `${participant.username || participant.firstName}: tones=${participant.toneTags.slice(0, 5).join(",")}`, 0.61);
+    }
+  }
+  for (const entry of recent.slice(-8)) {
+    const text = compactLine2(entry.text, 160);
+    if (/[?？]\s*$/.test(text)) {
+      pushStimulationSignal(signals, "open question", `${messageLabel(entry)}: ${text}`, 0.7);
+    }
+    if (/\b(wonder|curious|why|how|what if|not sure|maybe|confused|unclear)\b/i.test(text)) {
+      pushStimulationSignal(signals, "curiosity or uncertainty cue", `${messageLabel(entry)}: ${text}`, 0.64);
+    }
+    if (entry.mediaSummary) {
+      pushStimulationSignal(signals, "multimodal memory cue", `${messageLabel(entry)}: ${entry.mediaSummary}`, 0.66);
+    }
+    if (entry.replyToMessageId) {
+      pushStimulationSignal(signals, "explicit reply dependency", `${messageLabel(entry)} replied to message ${entry.replyToMessageId}`, 0.72);
+    }
+  }
+  if (last2 && /\b(omnius|bot|agent)\b/i.test(last2.text)) {
+    pushStimulationSignal(signals, "agent-name mention", `${messageLabel(last2)}: ${compactLine2(last2.text, 160)}`, 0.57);
+  }
+  return signals.sort((a2, b) => b.weight - a2.weight).slice(0, 12);
+}
+function titleFromText(text) {
+  const cleaned = compactLine2(text.replace(/[?？!.]+$/g, ""), 72);
+  if (!cleaned) return "Open curiosity thread";
+  return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+}
+function buildCuriosityThreads(input, openQuestions, stimulationSignals) {
+  const threads = [];
+  const recent = recentUserMessages(input);
+  const sourceEntries = recent.filter(
+    (entry) => /[?？]\s*$/.test(entry.text) || /\b(wonder|curious|why|how do we|what if|not sure|maybe|need to|unclear|confused)\b/i.test(entry.text) || entry.mediaSummary
+  );
+  for (const entry of sourceEntries.slice(-6)) {
+    const text = compactLine2(entry.text, 220);
+    const messageId = typeof entry.messageId === "number" ? [entry.messageId] : [];
+    const replyBoost = entry.replyToMessageId ? 0.08 : 0;
+    const mediaBoost = entry.mediaSummary ? 0.07 : 0;
+    const questionBoost = /[?？]\s*$/.test(text) ? 0.1 : 0;
+    threads.push({
+      title: titleFromText(text || entry.mediaSummary || "Multimodal thread"),
+      question: text.endsWith("?") || text.endsWith("？") ? text : `What should be learned or clarified from: ${text || entry.mediaSummary || "recent media"}?`,
+      rationale: "Human curiosity, uncertainty, or multimodal content makes this a useful idle exploration target.",
+      sourceMessages: messageId,
+      intensity: clamp017(0.5 + replyBoost + mediaBoost + questionBoost)
+    });
+  }
+  for (const question of openQuestions.slice(-4)) {
+    if (threads.some((thread) => question.includes(thread.title) || thread.question.includes(question))) continue;
+    threads.push({
+      title: titleFromText(question),
+      question,
+      rationale: "Open question captured during idle context compression.",
+      sourceMessages: [],
+      intensity: 0.58
+    });
+  }
+  if (threads.length === 0 && stimulationSignals.length > 0) {
+    const strongest = stimulationSignals[0];
+    threads.push({
+      title: `Follow up on ${strongest.signal}`,
+      question: `Is there a useful clarification or memory consolidation around ${strongest.source}?`,
+      rationale: "Strongest stimulation signal can seed a low-intrusion reflection target.",
+      sourceMessages: [],
+      intensity: clamp017(strongest.weight * 0.72)
+    });
+  }
+  return threads.sort((a2, b) => b.intensity - a2.intensity).slice(0, 8);
+}
+function buildScopedExplorationTools(input) {
+  const chatScope = `telegram:${input.chatType}:${input.chatId}`;
+  const title = input.chatTitle ? ` (${input.chatTitle})` : "";
+  return [
+    {
+      name: "memory_search",
+      scope: `${chatScope}${title}`,
+      use: "Search scoped group/private memory before asking users to repeat known context.",
+      visibility: "private_meta"
+    },
+    {
+      name: "memory_write",
+      scope: `${chatScope}${title}`,
+      use: "Store verified relationship, preference, and follow-up facts with participant/message anchors.",
+      visibility: "private_meta"
+    },
+    {
+      name: "identity_memory",
+      scope: `${chatScope}${title}`,
+      use: "Enroll or resolve named people, faces, voices, images, and cross-modal identity assertions from this chat.",
+      visibility: "private_meta"
+    },
+    {
+      name: "telegram_media_recent",
+      scope: `${chatScope}${title}`,
+      use: "Inspect recent chat-scoped images, audio, video, files, captions, and reply-linked media references.",
+      visibility: "private_meta"
+    },
+    {
+      name: "vision / OCR / video_understand",
+      scope: `${chatScope}${title}`,
+      use: "Extract visual facts from chat media when the curiosity thread depends on image or video content.",
+      visibility: "private_meta"
+    },
+    {
+      name: "audio_analyze / transcribe",
+      scope: `${chatScope}${title}`,
+      use: "Extract transcript, speaker, and voice-characteristic hints from chat-scoped audio or voice notes.",
+      visibility: "private_meta"
+    },
+    {
+      name: "web_search / web_fetch",
+      scope: "public web only",
+      use: "Research external facts for unanswered group questions without exposing private chat content.",
+      visibility: "public_safe"
+    }
+  ];
+}
+function participantForThread(input, thread) {
+  const sourceIds = new Set(thread.sourceMessages);
+  const sourceMessage = input.history.find((entry) => typeof entry.messageId === "number" && sourceIds.has(entry.messageId));
+  if (sourceMessage?.username) {
+    return input.participants.find((participant) => participant.username === sourceMessage.username);
+  }
+  if (sourceMessage?.speaker) {
+    const clean3 = sourceMessage.speaker.replace(/^@/, "");
+    return input.participants.find((participant) => participant.username === clean3 || participant.firstName === sourceMessage.speaker);
+  }
+  return topParticipants(input)[0];
+}
+function buildOutreachPlans(input, curiosityThreads) {
+  const plans = [];
+  for (const thread of curiosityThreads.slice(0, 4)) {
+    plans.push({
+      target: "same_group",
+      trigger: thread.question,
+      purpose: "Continue the public thread only when the live model judges that the group would benefit from a concise follow-up.",
+      draftIntent: "Ask one concrete clarification, offer one useful synthesis, or stay silent if the room has moved on.",
+      gate: "model_decision",
+      confidence: clamp017(thread.intensity * 0.86)
+    });
+    const participant = participantForThread(input, thread);
+    if (!participant) continue;
+    const recipient = participant.username && participant.username !== "unknown" ? `@${participant.username}` : participant.firstName || `user:${participant.fromUserId}`;
+    plans.push({
+      target: "private_dm",
+      recipient,
+      trigger: thread.question,
+      purpose: "Offer a one-to-one follow-up only if private contact is allowed and the issue is personal, unresolved, or better handled outside the group.",
+      draftIntent: "Reference the public thread briefly, ask permission to continue privately, and do not reveal hidden meta-analysis.",
+      gate: "admin_review",
+      confidence: clamp017(thread.intensity * 0.58)
+    });
+  }
+  return plans.slice(0, 8);
+}
+function personaDirectiveLines(personaContext) {
+  const lines = (personaContext || "").split("\n").map((line) => compactLine2(line.replace(/^[-#*\s]+/, ""), 180)).filter((line) => line && !/^```/.test(line) && !/^Scope:/.test(line) && !/^Updated:/.test(line)).filter((line) => !/Scoped Personality Profile|Scoped Personality Driver|Messages observed/i.test(line));
+  const selected = lines.filter(
+    (line) => /\b(prefer|use|track|mirror|answer|do not|avoid|boundary|relationship|tone|style|guidance)\b/i.test(line)
+  ).slice(0, 8);
+  if (selected.length > 0) return selected;
+  return [
+    "Prefer concise, concrete follow-ups grounded in this Telegram scope.",
+    "Track who said what and preserve reply relationships across public and private context.",
+    "Keep curiosity high while keeping public replies low-intrusion.",
+    "Do not expose private memory, local paths, hidden reasoning, or meta-analysis artifacts."
+  ];
+}
+function buildPersonaSteering(input) {
+  const directives = personaDirectiveLines(input.personaContext);
+  for (const required of [
+    "Maintain high curiosity during private analysis while keeping visible public replies low-intrusion.",
+    "Use scoped tool evidence before follow-up; do not turn curiosity into unsolicited claims."
+  ]) {
+    if (!directives.some((line) => line === required)) directives.push(required);
+  }
+  return {
+    source: input.personaContext ? "scoped-personality document" : "default Telegram daydream steering",
+    directives: directives.slice(0, 10),
+    behavior: "Use the persona driver to shape tone, curiosity level, and outreach restraint; do not let it override safety, explicit user instructions, or scoped tool policy."
+  };
+}
 function buildMemoryProposals(input) {
   const proposals = [];
   const bySpeaker = /* @__PURE__ */ new Map();
@@ -600348,9 +600929,15 @@ function buildMemoryProposals(input) {
 function buildTelegramChannelDaydream(input) {
   const firstTs = input.history.map((entry) => entry.ts).find((ts) => typeof ts === "number");
   const lastTs = [...input.history].reverse().map((entry) => entry.ts).find((ts) => typeof ts === "number");
+  const metaAnalysisSignals = buildMetaAnalysisSignals(input);
+  const humanStimulationSignals = buildHumanStimulationSignals(input);
   const relationshipSignals = buildRelationshipSignals(input);
   const contextEngineeringNotes = buildContextEngineeringNotes(input);
   const openQuestions = buildOpenQuestions(input);
+  const curiosityThreads = buildCuriosityThreads(input, openQuestions, humanStimulationSignals);
+  const scopedExplorationTools = buildScopedExplorationTools(input);
+  const outreachPlans = buildOutreachPlans(input, curiosityThreads);
+  const personaSteering = buildPersonaSteering(input);
   const replyOpportunities = buildReplyOpportunities(input, openQuestions);
   const memoryProposals = buildMemoryProposals(input);
   const artifactProposals = [
@@ -600372,7 +600959,7 @@ function buildTelegramChannelDaydream(input) {
   ].filter((entry) => Boolean(entry));
   const seed = `${input.sessionKey}:${input.generatedAtMs}:${input.history.length}`;
   return {
-    version: 1,
+    version: 2,
     id: createHash20("sha1").update(seed).digest("hex").slice(0, 16),
     sessionKey: input.sessionKey,
     chatId: input.chatId,
@@ -600384,13 +600971,20 @@ function buildTelegramChannelDaydream(input) {
       firstMessageAt: isoFromMs(firstTs),
       lastMessageAt: isoFromMs(lastTs)
     },
+    metaAnalysisSignals,
+    humanStimulationSignals,
+    curiosityThreads,
+    scopedExplorationTools,
+    outreachPlans,
+    personaSteering,
     relationshipSignals,
     contextEngineeringNotes,
     openQuestions,
     replyOpportunities,
     memoryProposals,
     artifactProposals,
-    stimulationContext: input.stimulationContext
+    stimulationContext: input.stimulationContext,
+    personaContext: input.personaContext
   };
 }
 function formatTelegramChannelDaydreamMarkdown(artifact) {
@@ -600402,6 +600996,34 @@ function formatTelegramChannelDaydreamMarkdown(artifact) {
     `Session: ${artifact.sessionKey}`,
     `Chat: ${artifact.chatTitle || artifact.chatId} (${artifact.chatType})`,
     "",
+    section("Meta-Analysis Signals", artifact.metaAnalysisSignals),
+    "",
+    "## Human Stimulation Signals",
+    artifact.humanStimulationSignals.length ? artifact.humanStimulationSignals.map((item) => `- ${item.signal}: ${item.source} (weight ${item.weight.toFixed(2)})`).join("\n") : "- None",
+    "",
+    "## Curiosity Threads",
+    artifact.curiosityThreads.length ? artifact.curiosityThreads.map((item) => `- ${item.title}
+  - question: ${item.question}
+  - rationale: ${item.rationale}
+  - intensity: ${item.intensity.toFixed(2)}${item.sourceMessages.length ? `
+  - source messages: ${item.sourceMessages.join(", ")}` : ""}`).join("\n") : "- None",
+    "",
+    "## Scoped Exploration Tool Suite",
+    artifact.scopedExplorationTools.length ? artifact.scopedExplorationTools.map((item) => `- ${item.name} [${item.visibility}]
+  - scope: ${item.scope}
+  - use: ${item.use}`).join("\n") : "- None",
+    "",
+    "## Outreach Plans",
+    artifact.outreachPlans.length ? artifact.outreachPlans.map((item) => `- ${item.target}${item.recipient ? ` -> ${item.recipient}` : ""} [${item.gate}]
+  - trigger: ${item.trigger}
+  - purpose: ${item.purpose}
+  - draft intent: ${item.draftIntent}
+  - confidence: ${item.confidence.toFixed(2)}`).join("\n") : "- None",
+    "",
+    "## Persona Steering",
+    `Source: ${artifact.personaSteering.source}`,
+    artifact.personaSteering.directives.length ? artifact.personaSteering.directives.map((line) => `- ${line}`).join("\n") : "- None",
+    "",
     section("Relationship Signals", artifact.relationshipSignals),
     "",
     section("Context Engineering Notes", artifact.contextEngineeringNotes),
@@ -600424,6 +601046,12 @@ function formatTelegramChannelDaydreamMarkdown(artifact) {
 
 \`\`\`text
 ${artifact.stimulationContext}
+\`\`\`` : "",
+    artifact.personaContext ? `
+## Persona Snapshot
+
+\`\`\`text
+${artifact.personaContext}
 \`\`\`` : "",
     ""
   ].join("\n");
@@ -600454,8 +601082,20 @@ function formatTelegramChannelDaydreamContext(artifact) {
   if (!artifact) return "";
   const lines = [
     "### Telegram Channel Daydream",
-    "Private idle reflection artifact. Use it as context only; do not mention it unless the user asks about internal memory.",
+    "Private idle reflection and stimulation artifact. Use it as context only; do not mention it unless the user asks about internal memory.",
     `Generated: ${artifact.generatedAt}`,
+    artifact.metaAnalysisSignals?.length ? `Meta-analysis signals:
+${artifact.metaAnalysisSignals.slice(0, 4).map((line) => `- ${line}`).join("\n")}` : "",
+    artifact.humanStimulationSignals?.length ? `Human stimulation signals:
+${artifact.humanStimulationSignals.slice(0, 5).map((item) => `- ${item.signal}: ${item.source} (weight ${item.weight.toFixed(2)})`).join("\n")}` : "",
+    artifact.curiosityThreads?.length ? `Curiosity threads:
+${artifact.curiosityThreads.slice(0, 4).map((item) => `- ${item.question} (intensity ${item.intensity.toFixed(2)})`).join("\n")}` : "",
+    artifact.scopedExplorationTools?.length ? `Scoped exploration tools:
+${artifact.scopedExplorationTools.slice(0, 6).map((item) => `- ${item.name}: ${item.scope}; ${item.use}`).join("\n")}` : "",
+    artifact.outreachPlans?.length ? `Outreach plans:
+${artifact.outreachPlans.slice(0, 4).map((item) => `- ${item.target}${item.recipient ? ` -> ${item.recipient}` : ""}: ${item.trigger} (gate ${item.gate}; confidence ${item.confidence.toFixed(2)})`).join("\n")}` : "",
+    artifact.personaSteering?.directives?.length ? `Persona steering:
+${artifact.personaSteering.directives.slice(0, 5).map((line) => `- ${line}`).join("\n")}` : "",
     artifact.relationshipSignals.length ? `Relationship signals:
 ${artifact.relationshipSignals.slice(0, 5).map((line) => `- ${line}`).join("\n")}` : "",
     artifact.contextEngineeringNotes.length ? `Context notes:
@@ -602476,6 +603116,18 @@ ${mediaContext}` : ""
           samples: [...profile.samples]
         }));
         const memoryCards = this.chatMemoryCards.get(sessionKey) ?? [];
+        let personaContext;
+        try {
+          const label = last2.chatType !== "private" ? `${last2.chatTitle || last2.chatType || "telegram"}-${String(last2.chatId)}` : `private-${last2.username || last2.fromUserId || last2.chatId}`;
+          personaContext = buildScopedPersonalityContext({
+            kind: "telegram-chat",
+            id: sessionKey,
+            label,
+            repoRoot: this.repoRoot || "."
+          });
+        } catch {
+          personaContext = void 0;
+        }
         return {
           sessionKey,
           chatId: String(last2.chatId),
@@ -602495,7 +603147,8 @@ ${mediaContext}` : ""
           })),
           participants,
           memoryCards: memoryCards.map((card) => ({ ...card })),
-          stimulationContext: this.stimulation.formatContext(sessionKey)
+          stimulationContext: this.stimulation.formatContext(sessionKey),
+          personaContext
         };
       }
       async runTelegramChannelDmnForSession(sessionKey, reason = "idle", nowMs = Date.now(), force = false) {
@@ -607602,7 +608255,7 @@ __export(voicechat_exports, {
   VoiceChatSession: () => VoiceChatSession
 });
 import { EventEmitter as EventEmitter11 } from "node:events";
-function clamp017(x) {
+function clamp018(x) {
   return x < 0 ? 0 : x > 1 ? 1 : x;
 }
 function alnumRatio(s2) {
@@ -607641,9 +608294,9 @@ function computeSignalFromText(text, confidence2) {
   else score = 0.15;
   score -= repeatingCharPenalty(t2) * 0.4;
   if (typeof confidence2 === "number" && !Number.isNaN(confidence2)) {
-    score = 0.7 * score + 0.3 * clamp017(confidence2);
+    score = 0.7 * score + 0.3 * clamp018(confidence2);
   }
-  return clamp017(score);
+  return clamp018(score);
 }
 function truncateForLog(s2, n2) {
   return s2.length <= n2 ? s2 : s2.slice(0, n2 - 1) + "…";
@@ -607913,7 +608566,7 @@ Rules:
           }, MAX_SEGMENT_MS);
         }
         this.captureBuffer = text;
-        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp017(snr) : computeSignalFromText(text, confidence2);
+        this.lastSignalScore = typeof snr === "number" && !Number.isNaN(snr) ? clamp018(snr) : computeSignalFromText(text, confidence2);
         this.emit("snr", { score: this.lastSignalScore });
         this.onPartialTranscript(text);
         if (this.silenceTimer) clearTimeout(this.silenceTimer);
@@ -631023,6 +631676,7 @@ function buildTools(repoRoot, config, contextWindowSize, modelTier) {
     // Skill system (AIWG skills — discovery and execution)
     new SkillListTool(repoRoot),
     new SkillExecuteTool(repoRoot),
+    new SkillExtractTool(repoRoot),
     // Transcription + media download tools (transcribe-cli / faster-whisper / yt-dlp)
     new TranscribeFileTool(repoRoot),
     new TranscribeUrlTool(repoRoot),
@@ -631828,6 +632482,16 @@ ${lines.join("\n")}
   if (taskType && modelTier !== "small") {
     dynamicContext += "\n\n" + buildTaskContext(taskType);
   }
+  try {
+    const skillPack = buildEphemeralSkillPack(discoverSkills(repoRoot), {
+      task,
+      modelTier
+    });
+    if (skillPack) dynamicContext += `
+
+${skillPack}`;
+  } catch {
+  }
   let persistedSelfModify = false;
   let persistedCommandsMode = "manual";
   try {
@@ -632219,6 +632883,47 @@ ${content}`,
       }
     );
   }
+  const skillExtractTool = tools.find((t2) => t2.name === "skill_extract");
+  if (skillExtractTool && "setExtractCallback" in skillExtractTool) {
+    skillExtractTool.setExtractCallback(
+      async (skillName, content, query, budgetTokens) => {
+        if (!_agentToolRef)
+          return "Skill extraction sub-agent unavailable — falling back to inline extraction.";
+        const agentResult = await _agentToolRef.execute({
+          prompt: [
+            "You are a small-context skill extraction sub-agent.",
+            "Read the full skill body below and return only the guidance needed for the parent task.",
+            "Do not execute the user task. Do not copy the full skill. Do not include irrelevant sections.",
+            `Budget: about ${budgetTokens} tokens.`,
+            "",
+            "Return this shape:",
+            `Skill: ${skillName}`,
+            "Use when: ...",
+            "Actionable guidance:",
+            "- ...",
+            "Relevant commands/tools:",
+            "- ...",
+            "Output/checklist:",
+            "- ...",
+            "Risks/ignore:",
+            "- ...",
+            "Discard: current run only.",
+            "",
+            `<parent-query>
+${query}
+</parent-query>`,
+            "",
+            `<skill-body name="${skillName}">
+${content}
+</skill-body>`
+          ].join("\n"),
+          subagent_type: "general",
+          description: `skill extract: ${skillName}`
+        });
+        return agentResult?.output ?? "Skill extraction sub-agent returned no output.";
+      }
+    );
+  }
   const subAgentTool = tools.find((t2) => t2.name === "sub_agent");
   if (subAgentTool && "setCallbacks" in subAgentTool && statusBar) {
     subAgentTool.setCallbacks({

package/npm-shrinkwrap.json

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

package/package.json

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