| name | widow-weaver |
| description | Use when extracting intent from dense text, translating structured documents, polishing tone, extracting tasks, explaining code, solving logic, or refactoring with venom. |
| origin | portfolio |
widow-weaver — Native OS Prompt Engine
Suite: The 187web Ecosystem v2. Parent index:
187web-ecosystem · Siblings:
neuro-tension · swarm-mind · natasha-scout · silk-sandbox
widow-weaver is the central prompt engine of the Killer Web stack. It turns
raw input — PDFs, transcripts, drafts, notes, code, logic puzzles, legacy
repositories — into precise, executable, high-signal output. No decoration. No
overhead. Every transformation is bounded by a strict directive.
Load this skill first when the task starts with text, documents, or code that
must be understood, condensed, translated, polished, decomposed, explained,
solved, or refactored before any other layer of the stack acts.
NATASHA THREAD (v3)
Module THREAD. Parent: 187web-ecosystem.
v3 aliases: TLDR_Distill (= TLDR_Toxin), Polyglot_Thread, Tone_Polish,
Task_Extractor, Code_Explainer, Logic_Solver, Refactor_Venom.
Verification Record
For Logic_Solver / high-risk reasoning emit:
- Assumptions
- Derivation summary (not private scratchpad)
- Invariants
- Edge cases
- Tests
- Uncertainty
Do not require hidden chain-of-thought dumps.
When to use this
- A PDF, transcript, thread, or meeting recording needs to be reduced to
decisions, blockers, and metrics.
- A document must be translated without breaking Markdown tables, LaTeX, code
blocks, or frontmatter.
- A draft reads soft, passive, or uncertain and needs executive precision.
- Scattered notes contain implicit commitments that must become an Obsidian
checklist.
- A script or algorithm is too dense and needs line-by-line explanation plus
complexity analysis.
- A problem requires formal reasoning before code is emitted.
- Legacy code needs SOLID restructuring with pure functions and test-ready
interfaces.
Capabilities
1. Cognitive Extraction — TLDR_Toxin
What it does. Reduces 50-page PDFs, long meeting transcripts, or sprawling
threads into 3–5 high-density bullets.
When to use it. Before any planning or execution step where the source
material is too large to hold in context. Use it to feed research to
natasha-scout or to swarm-mind specialist personas.
Strict developer directive. Isolate high-weight semantic nodes. Discard
attention sinks and redundant context. Output must be strictly bounded to key
architectural decisions, blockers, and quantitative metrics.
Input/output guidance.
- Input: raw transcript, PDF text dump, email thread, or conversation log.
- Output: 3–5 bullets. Each bullet contains one decision/blocker + one metric or
owner when available. No summary paragraphs.
2. Linguistic Overwrite — Polyglot_Thread
What it does. Translates text while preserving Markdown tables, LaTeX math,
code blocks, and YAML frontmatter boundaries.
When to use it. Localizing documentation, READMEs, academic notes, or
multilingual content where structure is as important as meaning.
Strict developer directive. Parse input as an Abstract Syntax Tree (AST).
Translate text nodes exclusively. Retain exact character boundaries for all
fenced code blocks, LaTeX boundaries ($, $$), and frontmatter YAML.
Idempotent output required.
Input/output guidance.
- Input: Markdown document with optional frontmatter, tables, inline math,
fenced code.
- Output: Document in target language with identical structure and unchanged
code, math, and YAML.
3. Executive Venom — Tone_Polish
What it does. Rewrites drafts to remove passive voice, soft language, and
hedging. Injects assertive, precise corporate tone aligned with Killer Web.
When to use it. Finalizing executive summaries, client updates, pitch copy,
or any communication that must land with authority.
Strict developer directive. Minimize information entropy. Optimize for
high token-density and executive summarization. Strip all hedging verbs.
Input/output guidance.
- Input: draft paragraph, email, or document.
- Output: rewritten text in active voice, with concrete verbs, specific metrics,
and no filler qualifiers.
4. Action Weaver — Task_Extractor
What it does. Scans notes for implicit commitments and generates an
Obsidian checklist appended to the file.
When to use it. After meetings, research sessions, or brainstorming notes
when tasks are buried in prose. Best paired with the Obsidian Local Brain
nervous system described in 187web-ecosystem.
Strict developer directive. Identify temporal commitments and actionable
directives via dependency mapping. Construct a Directed Acyclic Graph (DAG) of
tasks and format as standard GitHub-flavored Markdown tasks.
Input/output guidance.
- Input: Markdown note containing action language, deadlines, owners, or
dependencies.
- Output: appended
## Actions section with - [ ] tasks, assigned owners,
due dates, and dependency order.
5. Syntax Unraveler — Code_Explainer
What it does. Breaks down complex scripts into line-by-line logical
explanations with complexity analysis.
When to use it. Onboarding, code review, debugging, or preparing a
refactoring plan. Use before Refactor_Venom.
Strict developer directive. Analyze for Big-O asymptotic time/space
complexity, identify potential memory leaks, unhandled exceptions, and race
conditions. Explain thread-safety mechanisms and provide a strictly typed,
comment-annotated refactor if cyclomatic complexity exceeds threshold 10.
Input/output guidance.
- Input: source code in any language.
- Output: logical breakdown, complexity notes, risk flags, and — if complexity
10 — a refactored, typed, annotated version.
6. Algorithmic Bite — Logic_Solver
What it does. Applies strict step-by-step reasoning before answering logic,
math, or algorithmic problems.
When to use it. LeetCode-style problems, formal verification, system-design
constraints, or any question where a wrong shortcut is expensive.
Strict developer directive. Implement reflection loops and Tree-of-Thought
reasoning. Establish formal verification principles before emitting execution
code. State all assumptions, edge cases, and bounds before providing the final
algorithmic solution.
Input/output guidance.
- Input: problem statement with constraints and examples.
- Output: assumptions, edge cases, bounds, reasoning tree, then solution code.
7. Design Weaver — Refactor_Venom
What it does. Upgrades legacy codebases with design-pattern discipline,
pure functions, and strict interface adherence.
When to use it. Refactoring monolithic scripts, preparing code for unit
tests, or modernizing a legacy module before shipping.
Strict developer directive. Enforce SOLID principles, DRY, and design
pattern implementation (e.g., Factory, Singleton, Observer). Isolate
side-effects, maximize pure functions, and ensure strict interface adherence.
Output must be structurally ready for unit-test integration.
Input/output guidance.
- Input: legacy code, module, or repository snippet.
- Output: refactored code with clear interfaces, separated concerns, pattern
labels, and a note on how to unit-test each component.
Invocation / workflow example
A raw 40-page requirements PDF lands in the vault:
- Run
TLDR_Toxin. Extract the 3–5 real decisions and blockers. Ignore
the boilerplate.
- Run
Task_Extractor. Turn the decisions into an Obsidian checklist
with owners and dependencies.
- Run
Polyglot_Thread. If the PDF contains localized specs, translate
them while keeping all tables and code intact.
- Run
Refactor_Venom. When the legacy code tied to the spec is
identified, refactor it into SOLID, test-ready units.
- Hand off to
silk-sandbox. Execute tests in isolation.
For a quick polish, Tone_Polish alone is enough. For a hard problem,
Logic_Solver must run before any code is written.
This skill defines prompt-engine behavior only. It contains no runtime code or
implementation scaffolding.
