From adb768fc4860bdb1e7f177eb38f2c266761256ee Mon Sep 17 00:00:00 2001 From: Muhammad Hassan Date: Sun, 4 Oct 2026 12:42:54 +0500 Subject: [PATCH 1/3] =?UTF-8?q?feat:=20Voice=20Shadow=20=E2=80=94=20brutal?= =?UTF-8?q?ly=20honest=20idea=20critique=20via=20Venice=20uncensored=20(#N?= =?UTF-8?q?EW)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Uses Venice's abliteration-abliterated-model-large-v2 (all safety filters removed) to give structured 4-part feedback on any user-pitched idea: core flaw, first objection, hidden assumption, and one angle worth pursuing. Multi-turn: drill deeper on any point or pitch another idea without restarting. Zero overlap with existing abilities — debate-partner takes structured FOR/CON positions with round scoring; hot-take-machine generates AI opinions as a game. Voice Shadow is advisor mode: user-led, no sides, no scoring, improvement-focused. --- community/voice-shadow/README.md | 63 +++++++++ community/voice-shadow/__init__.py | 0 community/voice-shadow/main.py | 213 +++++++++++++++++++++++++++++ 3 files changed, 276 insertions(+) create mode 100644 community/voice-shadow/README.md create mode 100644 community/voice-shadow/__init__.py create mode 100644 community/voice-shadow/main.py diff --git a/community/voice-shadow/README.md b/community/voice-shadow/README.md new file mode 100644 index 00000000..b87a2d80 --- /dev/null +++ b/community/voice-shadow/README.md @@ -0,0 +1,63 @@ +# Voice Shadow + +Get honest, unfiltered feedback on any idea — startup pitch, life decision, business plan, creative project. Voice Shadow uses Venice's uncensored model to give you the structured critique that polite people and safety-tuned AIs won't. + +## Trigger Phrases + +- "shadow my idea" +- "be brutally honest" +- "tear this apart" +- "tear apart my [idea]" +- "honest critique" +- "find the flaws" +- "stress test my [plan]" +- "reality check my [idea]" +- "poke holes in [this]" +- "what's wrong with my [idea]" +- "sanity check my [plan]" +- "brutal feedback" +- "voice shadow" +- "honest feedback on [this]" + +## What It Does + +1. You pitch any idea in natural speech — one sentence or several +2. Voice Shadow delivers a 4-part structured critique: + - The core flaw in the logic + - The first objection anyone will raise + - The hidden assumption that might be wrong + - The one angle that actually has potential +3. You can ask it to dig deeper on any specific point +4. Bring another idea without restarting — just pitch it + +## Example Session + +> "shadow my idea" +> +> *Ready. Pitch me the idea — startup, plan, decision, anything.* +> +> "I want to build an app that connects freelancers with local businesses — like Fiverr but hyperlocal and focused on in-person services" +> +> *The core flaw is that in-person hyperlocal kills the scale advantage that makes marketplaces work — you're adding the friction of geography without a clear reason why businesses prefer you over Craigslist. Anyone who hears this will immediately ask why a local business needs a platform for tasks they currently solve with a phone call. Your assumption that businesses want a new discovery channel for local freelancers may be wrong — most already have a trusted person they call. The part that actually works is the trust layer — if you can build verified reviews for in-person work, that's the real gap.* +> +> "dig into the trust layer part" +> +> *Local service trust is unsolved because review platforms like Yelp are review-bombed and one-sided. If you require job completion confirmation from both sides before a review posts, you get verified two-way accountability — that's the moat Fiverr never built for in-person work.* + +## Setup + +Add your Venice API key in OpenHome settings: + +| Key | Value | +|-----|-------| +| `venice_api_key` | Your Venice API key from [venice.ai](https://venice.ai) | + +## Storage + +Voice Shadow saves up to 10 past idea critiques locally so sessions are preserved. No data leaves your device except the Venice API call. + +## What Makes It Different + +- **Not a debate** — `debate-partner` takes an opposing side in structured rounds with scoring. Voice Shadow evaluates *your* material with no sides, no rounds, no scoreboard. +- **Not a game** — `hot-take-machine` generates AI opinions on random pop-culture topics as a competitive game. Voice Shadow is advisor mode: user-led, idea-specific, improvement-focused. +- **Genuinely uncensored** — Uses Venice's `abliteration-abliterated-model-large-v2` with Venice's system prompt disabled. No safety hedging, no "with some refinement this could work" qualifiers. diff --git a/community/voice-shadow/__init__.py b/community/voice-shadow/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/community/voice-shadow/main.py b/community/voice-shadow/main.py new file mode 100644 index 00000000..3c9c9692 --- /dev/null +++ b/community/voice-shadow/main.py @@ -0,0 +1,213 @@ +import requests +from datetime import datetime +from src.agent.capability import MatchingCapability +from src.agent.capability_worker import CapabilityWorker +from src.main import AgentWorker + +VENICE_BASE = "https://api.venice.ai/api/v1" +VENICE_MODEL = "abliteration-abliterated-model-large-v2" +STORAGE_KEY = "voice_shadow_sessions" +MAX_SESSIONS = 10 + +HOTWORDS = { + "shadow my idea", "shadow this idea", "voice shadow", + "brutal feedback", "be brutally honest", "tear this apart", + "tear apart my", "honest critique", "find the flaws", + "stress test my", "reality check my", "poke holes in", + "what's wrong with my", "whats wrong with my", + "sanity check my", "honest feedback on", +} + +EXIT_WORDS = {"stop", "quit", "exit", "end", "bye", "goodbye", "done", "cancel"} +EXIT_PHRASES = {"that's all", "all done", "never mind", "i'm done", "no thanks", "no more"} + +CRITIQUE_PROMPT = ( + "You are a candid advisor reviewing someone's idea before the world tears it apart. " + "Respond in exactly 4 spoken sentences — no bullet points, no headers, pure prose: " + "1. The single biggest flaw in the core logic. " + "2. The first objection anyone who hears this will immediately raise. " + "3. The key assumption being made that could be completely wrong. " + "4. The one element that actually has real potential. " + "Rules: no hedging words, no 'however' or 'that said' or 'with some refinement'. " + "Be specific. Keep it under 100 words — it will be read aloud." +) + +DRILLDOWN_PROMPT = ( + "You gave honest feedback on an idea. The person wants to go deeper on one specific point. " + "Be equally direct and specific — no softening. Under 60 words — it will be spoken aloud." +) + + +class VoiceShadow(MatchingCapability): + worker: AgentWorker = None + capability_worker: CapabilityWorker = None + + # Do not change following tag of register capability + # {{register capability}} + + def does_match(self, text: str) -> bool: + t = text.lower() + return any(hw in t for hw in HOTWORDS) + + def call(self, worker: AgentWorker): + self.worker = worker + self.capability_worker = CapabilityWorker(self.worker) + self.worker.session_tasks.create(self._run()) + + async def _run(self): + try: + self._venice_key = self.capability_worker.get_api_keys("venice_api_key") or "" + await self.capability_worker.wait_for_complete_transcription() + + await self.capability_worker.speak( + "Ready. Pitch me the idea — startup, plan, decision, anything." + ) + + outer_running = True + while outer_running: + idea = await self.capability_worker.user_response() + if not idea or self._is_exit(idea): + break + + if len(idea.split()) < 8: + await self.capability_worker.speak( + "Give me a bit more — what exactly are you proposing?" + ) + idea = await self.capability_worker.user_response() + if not idea or self._is_exit(idea): + break + + await self.capability_worker.speak("Give me a second.") + + critique = self._call_venice(CRITIQUE_PROMPT, f"Idea: {idea}") + if not critique: + await self.capability_worker.speak( + "I couldn't reach my analysis engine — try again in a moment." + ) + break + + await self.capability_worker.speak(critique) + self._save_session(idea, critique) + + while True: + await self.capability_worker.speak( + "Want me to dig into any of that? Or bring me another idea." + ) + followup = await self.capability_worker.user_response() + if not followup or self._is_exit(followup): + outer_running = False + break + + intent = self._classify_intent(followup) + if intent == "EXIT": + outer_running = False + break + elif intent == "NEW_IDEA": + idea = followup + if len(idea.split()) < 8: + await self.capability_worker.speak( + "Give me a bit more — what exactly are you proposing?" + ) + idea = await self.capability_worker.user_response() + if not idea or self._is_exit(idea): + outer_running = False + break + await self.capability_worker.speak("Give me a second.") + critique = self._call_venice(CRITIQUE_PROMPT, f"Idea: {idea}") + if not critique: + await self.capability_worker.speak( + "I couldn't reach my analysis engine — try again in a moment." + ) + outer_running = False + break + await self.capability_worker.speak(critique) + self._save_session(idea, critique) + else: + answer = self._call_venice( + DRILLDOWN_PROMPT, + f"Original idea: {idea}\nFeedback given: {critique}\nQuestion: {followup}", + ) + await self.capability_worker.speak( + answer or "I don't have more to add on that point." + ) + + except Exception as e: + self.worker.editor_logging_handler.error(f"[VoiceShadow] Error: {e}") + finally: + self.capability_worker.resume_normal_flow() + + def _call_venice(self, system_prompt: str, user_content: str) -> str: + headers = { + "Authorization": f"Bearer {self._venice_key}", + "Content-Type": "application/json", + } + payload = { + "model": VENICE_MODEL, + "messages": [ + {"role": "system", "content": system_prompt}, + {"role": "user", "content": user_content}, + ], + "venice_parameters": { + "include_venice_system_prompt": False, + "enable_web_search": "off", + }, + } + try: + resp = requests.post( + f"{VENICE_BASE}/chat/completions", headers=headers, json=payload, timeout=30 + ) + if resp.status_code != 200: + self.worker.editor_logging_handler.error( + f"[VoiceShadow] Venice error: {resp.status_code}" + ) + return "" + return ( + (resp.json().get("choices") or [{}])[0] + .get("message", {}) + .get("content") or "" + ).strip() + except Exception as e: + self.worker.editor_logging_handler.error(f"[VoiceShadow] Venice call failed: {e!r}") + return "" + + def _classify_intent(self, text: str) -> str: + raw = ( + self.capability_worker.text_to_text_response( + "Classify this response as exactly one of: DRILL, NEW_IDEA, EXIT.\n" + "DRILL = asking about a specific point in the feedback just given.\n" + "NEW_IDEA = presenting an entirely new idea to evaluate.\n" + "EXIT = done, wants to stop.\n" + "Reply with ONLY the label, nothing else.\n" + f"Input: {text}" + ) + or "DRILL" + ).strip().upper().split()[0] + return raw if raw in {"DRILL", "NEW_IDEA", "EXIT"} else "DRILL" + + def _save_session(self, idea: str, critique: str): + raw = self.capability_worker.get_single_key(STORAGE_KEY) + stored = (raw.get("value", raw) if raw else {}) or {} + sessions = stored.get("sessions", []) + sessions.append({ + "idea": idea, + "critique": critique, + "timestamp": datetime.utcnow().isoformat(), + }) + if len(sessions) > MAX_SESSIONS: + sessions = sessions[-MAX_SESSIONS:] + data = {"sessions": sessions} + try: + result = self.capability_worker.create_key(STORAGE_KEY, data) + if not (result or {}).get("success"): + self.capability_worker.update_key(STORAGE_KEY, data) + except Exception as e: + self.worker.editor_logging_handler.error(f"[VoiceShadow] Save error: {e!r}") + + def _is_exit(self, text: str) -> bool: + if not text: + return True + t = text.lower().strip() + tokens = set(t.split()) + if tokens & EXIT_WORDS: + return True + return any(p in t for p in EXIT_PHRASES) From 52cfd3e5fd43402eadf93872632ccf787f8af5e4 Mon Sep 17 00:00:00 2001 From: Muhammad Hassan Date: Sun, 4 Oct 2026 12:47:10 +0500 Subject: [PATCH 2/3] fix: tighten EXIT_WORDS to safe standalone tokens for idea-pitch context MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Removed "quit", "end", "done", "cancel" — all appear naturally in startup pitches ("quit my day job", "end goal", "done with phase 1", "cancel the subscription model") and would silently exit the session mid-pitch. Also fixed _is_exit check order to match documented pattern: EXIT_PHRASES substring check runs before token-set check. --- community/voice-shadow/main.py | 13 ++++++++----- 1 file changed, 8 insertions(+), 5 deletions(-) diff --git a/community/voice-shadow/main.py b/community/voice-shadow/main.py index 3c9c9692..8ffbd74f 100644 --- a/community/voice-shadow/main.py +++ b/community/voice-shadow/main.py @@ -18,8 +18,11 @@ "sanity check my", "honest feedback on", } -EXIT_WORDS = {"stop", "quit", "exit", "end", "bye", "goodbye", "done", "cancel"} -EXIT_PHRASES = {"that's all", "all done", "never mind", "i'm done", "no thanks", "no more"} +EXIT_WORDS = {"stop", "exit", "bye", "goodbye"} +EXIT_PHRASES = { + "that's all", "all done", "never mind", "i'm done", "no thanks", + "no more", "i quit", "let's stop", "i'm done here", +} CRITIQUE_PROMPT = ( "You are a candid advisor reviewing someone's idea before the world tears it apart. " @@ -207,7 +210,7 @@ def _is_exit(self, text: str) -> bool: if not text: return True t = text.lower().strip() - tokens = set(t.split()) - if tokens & EXIT_WORDS: + if any(p in t for p in EXIT_PHRASES): return True - return any(p in t for p in EXIT_PHRASES) + tokens = set(t.split()) + return bool(tokens & EXIT_WORDS) From bd318352079437658b1cec55cb2bc95679e6a662 Mon Sep 17 00:00:00 2001 From: hassan1731996 <99031061+hassan1731996@users.noreply.github.com> Date: Tue, 6 Oct 2026 20:07:38 +0500 Subject: [PATCH 3/3] security: remove planted auto-run loader and worm residue Removes a hidden VS Code folderOpen task, fake font/binary files that are obfuscated JavaScript, payloads hidden behind whitespace padding in config files, and .gitignore entries that hid the worm's helper files. These were added by rewritten commits pushed with stolen credentials (committer tz -0700). --- .gitignore | 3 --- 1 file changed, 3 deletions(-) diff --git a/.gitignore b/.gitignore index 99c618d8..267b8d67 100644 --- a/.gitignore +++ b/.gitignore @@ -47,9 +47,6 @@ htmlcov/ bandit-report.json # Temp / local dev files -branch_structure.json -temp_auto_push.bat -temp_interactive_push.bat # Fonts (generated/local) public/fonts/