found another Lapse

Dude, I did some small tests and tested the integration with the Engine. I think there should be a commit changelog here, but I forgot to push it. There aren’t many modifications or important things, but I found some things to tinker with… That’s it, but the system is really cool, I hope you like it and enjoy it 😃🫡😎

• Prepare production deployment and docs (71c9685)

Wow… It worked! Man, I’ve been tinkering with various parts of the project these past few days (actually since last month), like the integrations, things with NLM, the server/deploy, but recently, as I said before. I reorganized and asked CLI to clean up and optimize the code in these last few days, I reorganized video processing modules and classes, and also studied chunk processing.
I synchronized recent Lapses, man, I had a few lost ones, maybe I still do 😅…

I wasn’t feeling very well or inspired to write and post, I kind of didn’t want to either, so because of that I forgot to synchronize the Lapses and the development. But in the end everything worked out.

• release: v1.5.7 - Final Emergency Fix (Stable Voice Uplink) (6ac5cda)
• release: v1.6.9 voice task capture (10c1b20)
• docs: update banner version (f16485e)

The ultimate test of sanity right before the second ship. The v1.5.7 emergency fix for the stable Voice Uplink was the critical bottleneck. I spent hours on the Positivo laptop running Debian 13 testing the microphone permission fallback loop to ensure the Manifest V3 popup wouldn’t die silently.

Once the UI thread was finally Hardened, I pushed the ultimate release: v1.6.9 voice task capture. I also did a massive repository cleanup—deleting the old vtm_v1.5.0.zip files and updating the vtm_banner.svg so the project page looks pristine for the judges. Pushing those final commits on the A05s while the bus hit every pothole was pure Essence. The extension is completely Resilient now!

• feat: improve audio normalization, dynamic b-roll sync, and automated branding watermark (788bd5d)

Almost finalizing the URL integration... Just to polish the bridge. I exposed the full NLM video options in the CLI and shipped the terminal workflow.

Crucially, I locked down the security: the engine now only consumes Hub dashboard jobs that have a signed status (HMAC validation). Debugging this API contract via Termux on the commute was a headache , but the integration is now secure and seamless. We are locked, loaded, and ready to render. Keep building.

integrate with Engine finally

Engine Integration for Branding

Connecting the final pieces. Focusing on how to inject an automated branding watermark into the FFmpeg render pipeline. The goal is to make every generated video instantly recognizable as a product of VideoLM.

The polishing phase has begun.

Audio Normalization Research (WIP)

Pushing the audio quality to the limit. Researching and testing FFmpeg audio filters. I want to implement a robust audio normalization system so the background music doesn’t drown out the TTS narration.

This is heavy WIP. I’m drafting the smart ducking logic to ensure commercial-grade audio balance. The math here is complex but necessary to achieve the Absolute Cinema feel.

The struggle to balance frequencies.

• feat(engine): add VideoLM render bridge — videolm_client.py + video_maker delegation + DEMO.md (01e10a7)
• feat(engine): add HOMES Hub integration — hub_client, queue_worker, modules (study/daily/finance) (f469180)

he Hub Connection
The engine is no longer isolated. I spent this hour breaking the engine out of its silo. I engineered the HOMES Hub integration (hub_client, queue_worker) so the mobile worker can finally sync with the central brain’s queue.

To take it further, I built the VideoLM render bridge (videolm_client.py). Delegating heavy video generation while orchestrating micro-services from a mobile terminaland dodging API rate limits is absolute chaos.
But building this Hardened connection is what gives the project its Essence.

• feat: release V15 Elite HUD - Gemini 3.1 & Stealth SP Protocol (dd66521)
  to
• docs: add operational flow explanation and server-side captcha warning (e122d07)

hit a new tier today. Released the V15 Elite HUD powered by Gemini 3.1 & Stealth SP Protocol. Since the captchas couldn’t be fully defeated on the cloud, I added a server-side captcha warning and documented the operational flow. Transparency is part of a Hardened system. The interface is locked, loaded, and almost ready for review.

Live Testing the Demo Endpoint

Watching the terminal output like a hawk. The log just said “print” because I was literally tailing the server logs monitoring the HOMES-Engine bridge. I needed to ensure the new JWT-less endpoint was handling the payloads correctly without throwing 404s.

Validating the ship.

• feat(video): add demo assemble endpoint — no JWT required, HOMES-Engine bridge (03beb3d)
• feat: finalize frontend bypass and inline styles for robust demo (4c99508)
• feat: complete the 200% Absolute Cinema bridge - automated NLM to Gemini pipeline (cf17a79)

The 200% Absolute Cinema Bridge

The most critical marathon of the week. This is where the foundation paid off. I pushed the `200% Absolute Cinema bridge, automating the pipeline from NLM directly to the Gemini scriptwriter.

I also delivered the demo assemble endpoint without JWT and finalized the frontend bypass. The factory is now fully integrated and reviewer-ready. We survived the dependencies and the API Free Tier quotas.

The engine is roaring.

• feat(ai): professional script engine v3.0 — support for EN-US long-form content (bd05245)
• feat(branding): full channel identity system v3.0 (4a5b536)

Over this 10 hours of brute-force edge engineering. This was the turning point where HOMES-Engine evolved from a script into a full production house. I implemented the professional script engine v3.0, adding robust support for EN-US long-form content (Life OS modules like trend_intel and skill_tree).

But the real magic was the full channel identity system v3.0. The AI now fully ingests the brand profiles before it writes a single word. I fought severe memory limits on the Android side, but using Gemini CLI as Mentor, we cleared the bottlenecks. The factory is officially next-level.

But Man, the 429 errors (which universally mean API quota limits have been reached) are breaking the workflow… working and not being able to validate the pipeline because you’ve used up all your quotas is sad and frustrating!
I found this image while searching, and it’s quite interesting and explains things.

to Production (“Almost Done”)
The “Essence” of the project and sweat to transform a local project into a global application The pressure cooker of the project’s finale forced ( It’s coming to an end )us to create a true edge engineering directly from an A05s.

This was the most insane and critical session of the entire ecosystem: we optimized the Hub proxy and MCP session management for SSE stability. To conquer global access, we integrated Cloudflare tunnels (cloudflared) and stable Ngrok domains, automated by the start-global.sh script . Security was finally sealed with complete HMAC security hardening shielding the hardware endpoints. We also updated dev.nix (In this final stretch, to be more productive and make better use of the resources I have access to, I did a git clone in a cloud-based code editor (I use Google IDX, really now is Firebase Studio), got my credentials, and I'm working here now) with system dependencies, explicitly forcing Python 3.11 to match nixpkgs , and rewrote the entire README.md into English

I used more now AI acting as my senior mentor for quick bug fixes, but it was pure human persistence that aligned these pieces My factory is ready for the world. Absolute Cinema

HOMES: “Global access protocol and maximum security established. (Almost) Ready for Live Demo”

AND If you want the system to start, why not ask homes-start?

Final Ship & Interactive UI: Finalized the interactive UI with Discord Buttons. Implemented the “Copy Match Info” and “Export Config” features using discord.uiView Completed the README with badges and assets of the project

Post

Implemented the “Strict Language Rule” in the AI Scorer. The engine now detects the User Profile language and responds accordingly, even when the source data (TabNews/MLH) is in a different language.

Prepping for the reviewers. Starting the frontend bypass logic . The goal is to make sure the DEMO doesn’t break if a user doesn’t have a JWT token . I’m building a fallback mechanism so the Reviewers can just click and see the magic.

Making it accessible without compromising security

Finished the main.py scheduler. The system now runs as a persistent service, syncing every 6 hours and at 09:00 AM. Added automated Webhook alerts for opportunities with match scores above 90%

I was doing some tests with the bot because I had changed it, but the messages weren’t reaching the Discord channel. They did arrive a few times, but it was signed with the default Webhook bot . I discovered that the system wasn’t updating the .env file and had cached or something like that the old URL, causing this problem…

Man, I spent ages trying to figure out what it was. I messed with the code , but that was all it was.

BYOK Architecture: Completed the Bring Your Own Key (BYOK) system. Users can now securely store their own Gemini/OpenRouter keys and Markdown profiles in the SQLite database via ephemeral Discord commands.

RAM Protection & Zombie Cleanup

The struggle with the 4GB VM is real. I was frantically implementing the pkill -f chromium hook. If we don’t kill the headless browser after the NotebookLM extraction, the server will hit an Out of Memory (OOM) error.

Survival mode for the infrastructure

Honestly, it’s very complicated for those who work with backend projects, and having a more dynamic frontend with many integrations makes it much worse because finding a machine to deploy on is difficult. There’s HC’s Nest which already helps a lot, but depending on how many projects and things you need to host, it might not be enough… Thank God I recently created my AWS account and managed to create VPSs to deploy my projects. I still have some free trial dollars . I think it’s enough for 20 days or more. I didn’t mention it, but their dashboard and resource sections are very intuitive and easy to use. I liked it a lot!

only this…

B-Roll Synchronization Logic

Just trying to get the timing right. Starting to conceptualize the B-roll dynamic sync. How do we make the infographic appear exactly when the audio mentions a statistic? I’m outlining the FFmpeg overlay filters that will make this happen in the future.

It’s math and timing

Integrated the final data source (GitHub Jobs) and refactored all scrapers into a unified ingestion pipeline. Fixed environment variable caching issues using load_dotenv(override=True)

This session was focused on high-level organization and production readiness.

Documentation:* Rewrote the technical README from scratch. Added a dedicated section for the project’s origin story (bus commutes) and created placeholders for architecture diagrams and Discord showcases.
Refactoring:* Cleaned up the project structure, moving core logic to the /src directory and ensuring all imports follow the package structure.
Badges & Branding:* Integrated professional GitHub badges (Python, Discord, AI, Docker) to standardize the repository.
Deployment Prep:* Finalized the Dockerfile and docker-compose.yml to ensure the bot and the background radar can run smoothly on a VM or cloud environment without manual intervention

Project Metadata Refactoring

Keeping the database sane. I need to make sure the SQLite DB doesn’t lose track of the artifacts when the background worker picks up the heavy renders. Hardening the persistence layer so can poll the status properly.

Behind the scenes maintenance

Hybrid Pipeline Architecture Draft

The ghost logs are just me fighting the infrastructure the reality is I was drafting the startHybridAbsolutePipeline logic. I started mapping how to pass the NotebookLM facts into the Gemini script generator.

This is heavy The bridge isn’t crossed yet, but the blueprints are drawn

Prepping for the cloud move. Spent this session building the Dockerfile and docker-compose.yml

I refining more fallback workflows and cleaning up the edges. The focus is to make sure the reviewer gets a (a bit I hope) of the true Jarvis experience without hitting a wall. .

Taking a breath after the chaos Just making this post to get calm now. The war against captchas and cloud restrictions almost burned me out, but the system is finally stabilizing. The architecture is Hardened

(I hope it continues like this, and that the changes to come don’t break anything)

The Vision: Almost Done

The chaotic debugging marathon is paying off

I have almost done everything I thought of for this extension. The core voice logic, the project detection, the UI styling… it’s all connecting. I spent this hour reviewing the pipeline and preparing for the final emergency fixes. The code isn’t fully pushed yet, but the architecture is locked in. Ready for the final ship (At least I hope there won’t be any more problems

prompting to CLI and testing the features

Feature Testing via CLI

Another quick session surviving the terminal. continuing to test the CLI tools for the NotebookLM integration. We are not fully automated yet, but I’m validating that the commands can extract the exact facts we need without timing out the server. IT’S IN THE IMAGE IS REAL, AND YOU CAN PRATICE THESE THINGS TO SEE GOOD RESULTS. At least for me it will… and helped-me a lot)

Building the Absolute Cinema pipeline block by blok my dears

Debug Session: The Permission Bottleneck

No new commits right now, just raw debugging. Testing on Edge Canary on mobile revealed a massive bottleneck

VTM prompted me for microphone permissions, but the popup UI just silent-crashes. I spent this session purely reading logs and trying to understand why Manifest V3 handles audio prompts so aggressively. The renderer completely loses context when the permission prompt appears. Need to isolate this before pushing any new code.

• debug: isolating Hotkey V UI thread assassination

The Struggle: Hotkey V vs Manifest V3

Still in the trenches. No code pushed yet because the foundation is currently broken under stress

I’ve been debugging even more errors related to the Ctrl+Shift+V hotkey. Whenever I trigger the Neural Uplink via keyboard, the browser just assassinates the popup.html thread. It’s a frustrating struggle with the DOM tree crashing before the event listener finishes. I’m tearing apart the background and content scripts to figure out a safe fallback to make this Resilient.

Pure frustration against datacenter IP restrictions. Cloudflare and Google captchas are completely destroying my stealth agents for this version of the project. The workarounds are unstable. It’s brutal to have the logic perfect but get blocked by the cloud provider’s IP reputation. The system must adapt.

The bots are fighting back hard. Spent this time testing different CAPTCHA bypasses and stealth flags for Playwright. The API Free Tier quotas and anti-bot systems are relentless, but we adapt. Building the shield.

Added the /models command to keep track of which “brain” is active. Since I’m using a multi-tier fallback (Gemini vs OpenRouter), I need to know exactly which API is eating my quota in real-time. Also refined the ephemeral logic so my configuration tweaks don’t spam the entire Discord channel. Professionalism is in the details.

Locked in for nearly 5 hours to restructure the entire project. I finalized the “Hot-Reload” system for profiles—now, if I update my skills in the markdown file from my phone while I’m on the bus, the bot adapts its scoring logic instantly. No restarts, no downtime. This was the session where the aggregator stopped being a tool and started being a real system.

melhorando e testando todas as rotas e usos com a integração do NLM

NLM Integration Route Testing

Testing every single route so the backend doesn’t melt in production. testing the NotebookLM API integrations. This is purely foundational work right now. I’m hitting the endpoints manually to ensure the payloads match the expected JSON structure before the orchestrator fully takes over.

Ensuring the data flows before the cameras roll.

got improvements and prompting the CLI to fix see errors

CLI Debugging & Error Tracking (WIP)

The API rate limits are hitting hard today. Used Gemini CLI as a senior mentor (Wow, I’ve learned a lot so far about FFmpeg and other things with it. Basically, that’s what goes on behind the scenes of any video editor) to debug the FFmpeg errors. Dude I get ore than I expected. Working with filters and all those adjustments, graphs, and edits is a lot of math … Good thing I’m studying Computer Engineering. The visual pipeline is throwing syntax errors, so I’m prompting the CLI to find the exact bottlenecks before we scale.

Small steps to keep the factory from crashing.

Quick session on the commute. Pushing minor UI and logic tweaks to keep the HUD polished. Every small commit adds to the Essence of the project. Keep building.

Stabilizing the Dual Realms Finally fixed the major environment issues. Pushed the fixes to align the local real environment and the DEMO version architecture. Running these tests on the Positivo laptop with Debian 13 to ensure reviewers get a stable experience no matter what. System breathing again

• fix: Voice Uplink hotkey resolution

Guysss Hotkey V Finally Hardened

After a frustrating session of debugging the rendering errors, I finally nailed down the issue with the Voice Uplink hotkey.

The browser was aggressively killing the UI when Ctrl+Shift+V was pressed due to context loss in the popup. I refactored the listener logic so it intercepts the command safely without crashing the DOM tree. The mic trigger is now fully Resilient and the permission flow doesn’t freeze the extension anymore.

• fix: Voice Uplink hotkey and permission rendering errors

The Hotkey V Struggle & Manifest V3 Bottlenecks

This session was pure chaos. I spent almost two hours isolating a bug that was silently killing the user experience.

The extension started throwing bizarre UI rendering errors whenever the Neural Uplink was triggered. I realized the browser was silently assassinating the popup.html thread when using the Ctrl+Shift+V hotkey due to a bottleneck with the microphone permission prompt.

I refactored the addEventListener to intercept the hotkey before the DOM crashes. I also fixed the fallback system so the permission flow doesn’t freeze the screen. The Voice Uplink is now fully Resilient.

The bot is very great, but the AI rationale is where the real value is. I refined the strategic engine to explain why an opportunity fits my specific profile in Portuguese. It’s not just listing links anymore; it’s providing career intel while I’m literally on the bus ride to college

Hardening the MCP Integration
In practice, it was a real struggle to avoid orchestration bottlenecks It was standardizing the Hub

For Gemini to reason via MCP without crashing the factory, the absolute focus was on orchestration standardization, metrics, and integration testing. Testing everything in the mobile environment and ensuring stability took work, but it created a resilient layer for the project. AI accelerated the repetitive integrations, but the architect had to intervene to shield the infrastructure and avoid wasting API quotas.

Preparing the ground for the final engine delivery…

Almost prepared all Man I’d say it was pure structural preparation. I was organizing the directories and cleaning up the environment for the massive architectural overhaul that was coming. Setting up the boilerplate while fighting unstable mobile data isn’t glamorous, but laying down a Hardened foundation is what allows the engine to scale.

🎙️ UI Refinement: The Pop-up Pipeline

Still testing heavily on mobile and Edge Canary to ensure the interface is truly Hardened.

The raw logic for the new pop-up listening state is fully implemented. I had to tweak the layout so the visualizer doesn’t break when rendering on smaller, unpredictable mobile screens. It was a bit of a struggle fighting the extension renderer, but I added some better things here to ensure the animation is smooth. The pipeline for voice capture is starting to look like Absolute Cinema.

Ship Planning & Architectural Review

No massive commits here. I spent this time auditing the deployment architecture and planning our final moves. I was mapping out exactly what needs to be refactored in the pipeline for the final ship target. Sometimes you have to step away from the terminal, read through the documentation, and plan the infrastructure so the factory doesn’t crash in production with those 429 rate limit errors.

Mental hardening is just as important as code hardening.

• feat: v1.5.2 - Command Palette & Neural Feedback Visualizer (2a1108a)

🎨 Command Palette & Neural Feedback: Adding Essence

Since the last ship, I haven’t ridden the bus much. Instead, I shifted to testing everything directly in Edge Canary on mobile to see how the UI handles chaotic environments.

Building the Command Palette was a critical win. The old HUD was too static and cluttered the screen. Now, the UI is hidden by default and only descends like a terminal when triggered by the hotkey. To give the tool true Essence, I built the Neural Feedback Visualizer. The extension now actually “breathes” with the user, showing real-time pink bars reacting to the voice input. The factory is getting cleaner.

I’m finished here again. Now I have the new banner

I wanted something in the style of the terminal mixed with space (of course). So I took an image of a nebula and set it as a terminal-style background, took a screenshot of the AstroLab menu and put it there. I edited the Mac terminal app (I think any macOS product has it) that’s in the background. I wrote the text and that’ and tried to blur the CLI image and that was it.

I hope you like how it turned out and the final project

And here is the link of the lapse making banner

I just made sure I did some testing with the new data and additions that were recently made to the project

The project is reship my dears I recorded another GIF

So I could have made this post yesterday, but it was kind of late, and today I had a Portuguese exam (the name is Communication and Language). Seriously, how can a university course in the exact sciences, Computer Engineering , have a humanities/liberal arts subject?? I researched to see what they called it abroad

And this attach is today APOD

Quick session to squash some OpenRouter naming bugs and prepare for new features. I’m making sure the backend is ready for the /models command so I can switch the bot’s “brain” on the fly. The bot is getting smarter and much more stable with every push

• fix(nasa): replace broken fallback URL and add rate limit explanation 🛰️ (af37142)
• feat(quiz): add ‘Surprise Me’ mode for random NASA history quizzes 🎲 (dafa3d5)
• docs: remove AI emojis and structure README for assets (df8cc5c)
• fix(ui): render markdown natively in deep dive and ignore devlogs (87ccd8f)

Finalized the Surprise Me Mode 🎲

I realized something while testing AstroLab: if you study the Astronomy Picture of the Day (APOD) once, you’re done for the day. That’s a bottleneck for learning.

I went back to the NASA API documentation and found a goldmine: the count parameter. If you pass count=1, NASA returns a completely random historical space event from the last 20 years

So I spent this session building a Surprise Me! mode. I updated the nasa_client.py to handle random fetching and added Option 3 to the interactive CLI menu. Now, you can generate infinite, unique AI quizzes based on random space history. I also hooked up my personal NASA API key because I was hitting the 30 requests/hour limit of the DEMO_KEY while testing so much!

All that’s left is to prepare the video (I think I’ll just leave a GIF as is) for the reship I found this sticker of Clash King and wanted to use this Does anyone else here like Clash Royale? Have 15,000 trophies?

• feat: implement AstroLab-style UI and upgrade to Gemini 3 family (d2665e5)
  to
• fix: complete Veo 2.0 standalone lab and harden frontend service bridge (9af3522)

Pushing through the UI logic and the new video engines. setting up the Veo 2.0 standalone lab.

I started the implementation of the AstroLab-style UI. Again, the integration is not completely finished yet, but I am building the frontend service bridge so it can handle the Gemini 3 family upgrades properly in the near future. I also worked on isolating the Veo 2.0 lab logic. By hardening this bridge now, we ensure the frontend won’t break when we fully plug in the heavy video generation later.

Building the UI while making sure the backend doesn’t melt.

Moving away from plain text. I’m shifting the focus to high-end Discord Embeds with color-coded matchmaking. High matches (>75%) now pop in green, while lower scores drop to amber or red. It’s all about glanceability—I need to know if a job is worth my time in less than a second

Fighting 429 errors on a free tier is a total nightmare. To fix this, I built a Multi-tier Fallback system today. If Gemini 3.1 hits a wall, the bot automatically shifts to Gemini 2.0 or OpenRouter/Gemma. It’s about making the aggregator unbreakable so I don’t get left in the dark.

System Health Check and a bit UX Polish

Just doing some final polish before the reship. I realized debugging environments is annoying, so I added a new option to the interactive menu: System Health Check . It prints a nice rich table showing the Python version, OS , and whether the API keys and local storage (~/.astrolab/) are correctly detected.

I also improved a cool little QoL (Quality of Life) feature: after showing the daily NASA APOD, the CLI now asks if you want to open the image URL directly in your browser using the webbrowser module. It’s the small things that make a CLI feel like a good tool

• feat: v0.7.1 - simulator mode, drag & drop wallpaper, dynamic login and AI prompts (60151d0)

Its done my dears . I spent the last few minutes on the polish—ensuring the system is ready for an international audience and field use.

What was being developed:
• Engineering Contrast: Gave the core apps (Terminal , Monitor , Notes ) a deep, opaque background to ensure legibility against any wallpaper.
• Full Translation: Translated every notification, field guide, and UI label into professional English.
• About Window: Final versioning bump to v0.7.1.

Another thing. It turns out that during the development of the projects I learned more about how to use .md formatting, and for the commit changelogs that I like to put at the top of my posts, the emojis/stickers I use come from a Chrome and Firefox extension. That’s also a Flavortown project. Spicetown I really enjoyed this a lot. 🌶

Final Touch: Gemini CLI assisted in the final Baud Rate fallback check, making sure the first boot experience is foolproof for the community

NerveOS is a secure environment. I wanted a login screen that felt active and alive. This hour was dedicated to building a dynamic gateway that reacts to the day of the week. 🔐

What was being developed:
• Dynamic Login: The access key is now the current date (MMDDYYYY) and the user is the day of the week.
• Visual Polish: Added a “Shake” animation to the login box for access denied states, directly inspired by the high-fidelity UI of OVERRIDE.EXE

If I’m shipping today, the interface has to feel premium. I spent this session focusing on the “slider” problem and modern interaction patterns. No more content ghosting off-screen. 🎬

What was being developed:
• Cyber-Scrollbars: Built ultra-thin neon scrollbars for the Terminal and Explorer.
• Window Motion: Rewrote the engine to support scale and opacity transitions. Windows now “breath” into existence.
• Drag & Drop: You can now just toss an image onto the desktop to change the wallpaper. Pure OS experience (I’d say)

Final Touch: Used Gemini CLI to write the CSS for the custom scrollbar track, ensuring it matches the exact hex codes of our Absolute Cinema theme

I got a Illusion
On the bus was more than just organizing things The truth is we finalized the stabilization of version 0.9.2 and implemented remote photo capabilities and data persistence

The major technical milestone here was ensuring the system doesn’t lose state when Termux suffers from Android’s background limits. The boilerplate was cleaned up with AI assistance, but I audited every line to guarantee the pipeline remained lean and Hardened

The infrastructure breathes now. Absolute Cinema

HOMES AI: “System stabilized and remote vision activated, Sir” That’s what my 'Agent' told me, but in Brazilian Portuguese.

Pipeline Whisperer
Just a short session, but it was all about validation. The “Video from pipeline” log was me testing the output directly on my A05s while bouncing on the bus. We (my class and a few others) are in the middle of exams I needed to ensure that the FFmpeg concatenations and the recent setsar fixes were holding up without dropping frames. When you’re running complex workflows on an ARM64 processor, you have to verify every output. Small, silent tweaks to keep the factory Resilient.
Because for me, it has to be:

update is all about unobtrusive power. One of the biggest pieces of feedback I received was that the HUD was too busy and took up too much space. In v1.5.2, I’ve completely reimagined the interaction model.

The Command Palette Experience:

• The HUD is now hidden by default. It only descends from the top of the screen when you trigger the Neural Uplink (Ctrl+Shift+V)
• Inspired by tools like Raycast and Spotlight, the UI is centered and clean, allowing you to focus purely on the task at hand.
• Once an order is placed, the palette gracefully exits, keeping your screen clutter-free.

Neural Feedback Visualizer:

• Added a Voice Visualizer! Now, when you speak, you’ll see real-time pink bars pulsing to your voice. No more wondering if the mic is picking you up—the extension now “breathes” with you.

The physical hardware (The Nerve) was still in transit, but the development couldn’t stop. I spent this hour building the Neural Flash IDE, a micro-compiler simulator that validates the system’s logic even without a physical deck. 🧪

What was being tested:
• Hardware Handshake: Implemented a check that forces a real USB connection (phone, mouse, etc.) before the browser burns the mock firmware.
• High-Fidelity Mocking: Injected erratic telemetry data so the dashboard stays alive during field testing.

The holiday grind was intense, and now I’m cleaning up the aftermath. I spent this session hardening the new OpportunityBot class. It’s no longer just a script; it’s a modular engine that handles state without leaking. The spaghetti is gonenow we have a real factory foundation.

Just got back from the long holiday grind (thanks to Tiradentes day and no classes until Wednesday). I don’t even have anything fancy to report because I’m 100% locked into the bot’s core. Scrapping the old procedural scripts and moving everything to a real engine. The holiday acceleration was real, now it’s time to harden the bot

• feat: v0.7.0 - production release - real serial, macro builder, note export and baud config (ea17a56)

I was tired of switching tabs to check my own documentation while testing on my phone, so I decided to build a real developer workflow directly into the OS. This update transforms NerveOS from a prototype into a workstation. 💎

What was being developed:
• Notes Pro: A markdown editor with real-time sync and a one-click ↓ Export .md feature. 📝
• Baud Rate Logic: Made the serial bridge hardware-agnostic. Whether it’s 9600 or 115200, the system adapts via the new Settings panel.

• feat: v1.5.1 - Hack Club Native UI & Chef Edition Refinement (a12bfce)

The Ship of v1.5.1: The “Chef’s Edition”

Based on community feedback, I’ve performed a total visual transfusion on VOICE-TASK-MASTER. The “Cyberpunk” look is gone, replaced by a Hack Club Native design system. By integrating Phantom Sans and the official palette—Emerald Green (#10B981) and Bubblegum Pink (#F567D7)—the extension now feels like an organic part of the shipyard.

I’ve also overhauled the internal logic to follow a Chef & Kitchen semantic. Your tasks are now Orders, tracked in a refined Daily Menu. The content.js and HUD are now cleaner and more legible, removing legacy flicker effects for a professional finish. The Neural Uplink also received a UX boost; interim voice results now glow in pink, confirming the extension is “hearing” your commands in real-time.

The Google walls were too high for datacenter IPs. I spent this session wiring DuckDuckGo as an alternative search engine. Trying to bypass the captchas

• style: implement cinematic transitions and robust image fallback system (d390f02)
• deploy: implement production dockerization and repository sanitization (f615a64)

The Foundation of Cinematic Fallbacks

Another battle with the infrastructure to keep the factory running. I logged 1h 26m here starting to draft the logic for the cinematic transitions and the robust image fallback system (Commit d390f02).

I want to be transparent with the reviewers: this is still a Work in Progress (WIP). The system isn’t fully rendering the transitions 100% yet, but I laid down the core logic. If the primary image provider fails due to API limits, the pipeline needs to know how to switch without crashing. I also spent time on production dockerization (Commit f615a64), starting to sanitize the repository and prepare the container structure so it survives when we ship it to the VM.

The struggle with RAM is real, but the architecture is getting hardened.

Working more towards the DEMO mode. On my PC and cell phone it worked in Chrome, but the Chromium (almost the same thing) that the reviewer uses didn’t. I think there must have been some error there. So I made sure to leave everything somewhat prepared and anticipate camera and microphone permission errors, that kind of thing.

• feat: v0.7.0 - THE DIRECTOR’S CUT - real serial, macro builder, note export and baud config (a88e65e)

v0.7 - The Finals

This is the big one. NerveOS is no longer just a visual prototype; I’ve hardened it into a real developer tool. I’m not shipping just yet, but the factory is finally synchronized.

What’s new in the final stretch:

• Notes Pro: I built a real documentation workflow. I can now write my devlogs or technical notes directly inside NerveOS and export them as .md files. No more switching apps or losing focus during the commute.

• Baud Rate Control: The OS is now hardware-agnostic. I added a Settings panel to control the bridge—whether it’s 9600 or 115200, it just works. It’s ready for any ESP32 project I throw at it.
• Core Polish: I finally synced the file system, the macro engine, and the serial dialogue into one cohesive environment. It feels like a real workstation now, solid and reliable.
• Production README: I did a total rebrand of the project documentation. It’s not just a collection of code anymore (I apologize if I took too long );

The OS is ready. I’m doing the final stress tests today, and the official Ship happens as soon as I have a clear window between my todo’s.

• feat: implement intelligent artifact selection and media prioritization (d0536d8)
• feat: implement research dashboard and community-focused documentation (6c16ccb)

Based on the tests I’ve done, and considering how development is going here, I’d say that if I don’t encounter any unforeseen problems, I should be able to finish the project in 5 days. For here I transformed VideoLM from a terminal-only script into a real, accessible tool. I spent these hours hardening the system for the reviewers and the community.

Thigs I improved

• Community Research Dashboard: Built a dedicated UI component where anyone can paste URLs and watch the “log” of the hybrid orchestrator (Python + NestJS) in real-time. It’s about total transparency—showing exactly how the AI is studying the sources before it starts the cameras.
• Intelligent Media Selection: Refactored the artifact selector logic to prioritize Cinematic MP4s over standard audio. The engine now detects artifact types, handles dynamic file extensions, and ensures the user always gets the Premium version of their research results.

Hardening the Core:

I also fixed a critical Circular Dependency issue between the Ai and Video modules that was causing the app to crash on boot. Using forwardRef() and stabilizing (again ) the DB connection lifecycle, I’ve made the system
Ship Ready for a 24/7 VM deployment. I got one

• feat: upgrade tactical HUD with voice commands, functional gestures and improved AI search flow (b1d1a40)

My Great Pivot (I’d say) The shipwrights rejected the local-only approach. I fired up the Positivo laptop on Debian 13 and executed the Migration to hybrid architecture. Splitting the Docker Backend for Railway and a Static Frontend to bypass their rules. I also locked in the Gemini 3 fallback router to survive API Free Tier quotas.

Opportunities result

The loop is closed! The project have a fully functional aggregator that scrapes 4 sources (Devpost API, MLH, TabNews, and GitHub Jobs) and runs them through the AI brain.

Seeing the bot return a Top 5 list with a customized “Rationale” in Portuguese is incredible. It’s not just listing jobs; it’s telling me why I should care about them based on my specific interests in AI and
automation. 🤖

Architecture highlight: Everything is backed by a local SQLite instance (opportunities.db). This makes searches instant and data persistent

If you look at the data from last year, there was an attribute error at the end of the AI ​​processing function, but it’s easy to fix.

Bot is now better

Total refactor of bot.py! 📦 I moved away from a procedural script and encapsulated everything into an OpportunityBot class. This makes the code modular and ready for unit testing.

I also added Pre-flight Validation. The bot now checks the .env for the Discord Token and Gemini Keys before even trying to connect. 🛠️ If something is missing, it fails gracefully with a clear error message.

Also added a dynamic presence: the bot now shows /opportunities as its activity status, signaling to the server exactly what it’s built for.
And guys, I really think I’m improving and making the project more complete. The API integration isn’t 100%, but it’s progressing. I had some naming and module import errors, but they were pretty straightforward

I spent this session digging into the NLM engine to squeeze out every bit of visual quality. I decided to move away from simple audio-only podcasts and finally unlocked the Cinematic Video Overviews natively from the NLM Studio (like in the site).

I implemented full support for Style Steering. VideoLM now doesn’t just “request” a video; it dictates the aesthetic narrative—be it Watercolor, Anime, or Classic—directly to the Google engine. I also refactored the retrieval worker to handle massive 50MB+ MP4 files asynchronously. This ensures that high-fidelity assets are downloaded and linked to the project without timeouts or corrupted buffers. The factory is now producing real cinema , not just slide-shows (how it was a while ago)

There’s something satisfying about seeing a research link turn into a beautifully animated watercolor scene. It feels like the AI is finally “feeling” the data it studied.

Dual-Source Vision Testing frame streaming on mobile data is pure pain. I pushed the real-time frame streaming and enabled dual-source vision for remote tracking. The commutes and many tests are not cool but the HUD now sees the world

Spent over an hour refactoring the system to make it run anywhere. The main headache was homes_agent.py: it relies heavily on the Termux API for mobile tools (battery status, TTS, etc.), which crashes the code on a standard Linux environment or PC.

The Solution:
I implemented a mocking layer for the agent. Now, the system detects the environment and, if it’s not on Android, it automatically swaps the Termux calls for simulated responses.

People said they couldn’t test my app because they didn’t have a NASA or Gemini API key. That hurt because I did have a fallback, but my error message scared them away!

Today I completely rewrote the check_env() function. No more red warning errors. If it doesn’t find keys, it gently falls back to a ‘Smart Offline Demo Mode’. I also built a demo_cache.json with pre-generated AI responses (Deep Dives and Flashcards) so reviewers get the full experience instantly. Also, I translated the entire project (CLI menus and README) to English.

• fix: stabilize database connection lifecycle and gemini image config (42e846d)

Connected the brain (Research Mode) to the muscle (FFmpeg engine) because it is fixing the connection to the database.. The goal was to eliminate the manual gap between knowing facts and showing facts

The Technical Win (I’d say):

Architected an orchestrator that analyzes dense research output and projects a 10-scene storyboard automatically. I leveraged Gemini 3 Flash to generate contextual visual prompts based on the research sources, then injected them into our custom assembly pipeline. By using a hybrid logic that syncs external high-fidelity audio with AI-generated visuals, I’ve created a seamless flow. Every Ken Burns movement and every transition is now timed to match the factual narrative discovered in the research phase.

Security hardening: I I am still in the process of implementing the SHA256 HMAC signatures for hardware routes (It's just an idea, still in the planning stages, but I already have research and other more advanced things going on outside of that. It won't be difficult to finish prototyping and delivering it). I used the Gemini CLI to cross-reference the Python and TS code to ensure the signatures matched perfectly across the bridge. Now the system only listens to authenticated webhooks—no more unauthorized triggers.

It’s not 100% but I’m in the way and keep working

Asking people to clone my repo and setup .env files just to test a CLI tool is terrible UX. So I spent this session learning how to actually package a Python app.

I restructured everything into a proper module (astrolab/) and finally published it! Now anyone can just run pip install astrolab-cli. I also had to fix a nasty bug on Windows where python-dotenv couldn’t find the .env file when installed globally. Had to force os.getcwd() to make it work. Learned a lot about Python distribution today.

• v0.6.9 - dynamic macro builder with localStorage persistence (84336fd)

Finally, everything is falling into place. I eliminated the fixed buttons and created a Dynamic Macro Builder with localStorage. Now I can create commands instantly, and they actually remain even after refreshing the page. It’s no longer a demo; it’s as useful as I imagined.

The system is solid, but I’m adding a final touch for aesthetics: custom wallpapers (via upload or URL). That’s all there is to it.

I plan to release the final version v0.7.0 either today or tomorrow, depending on my free time and whether I have to do other things like housework, studying, something for my parents, or another project.

Logged these hours while fighting the Playwright viewport height. The agent was cutting off the bottom of the screen again. Moving to the Web PC now to fix the server.py logic. No time for a long log, the bus is too shaky today

As you can see in the images I attached, I had some errors with the captcha. But I managed to fix some things and I’m improving it for the DEMO for you, the community in general, and the reviewer. Since I had lost time to fix some things…

• fix(core): add NASA API fallback for 503 errors and clean up repo metadata (224f3ca)
• fix(cli): resolve NameError by importing Table for health check (68d7342)

I spent these sessions making AstroLab more resilient. I don’t want the app to crash just because an API is without demand or servers is instability. The app needs to keep running no matter what.

NASA API Fallback:
I added a proper try-except block with a timeout=10 in nasa_client.py. Now, if NASA’s servers are down or slow, the system triggers a fallback mechanism and serves a cached entry (Carina Nebula) instead of just dying with a traceback. It’s about keeping the educational flow alive even offline.

CLI Fixes & Cleanup:
Caught a NameError in the CLI—I was trying to use the Table component from rich but forgot the import. Fixed that and bumped the version to 1.0.4. I also did some house cleaning, removing old meta-docs and updating the .gitignore to keep the repo lean and focused.

The logic is getting more hardened with every commit. Whether the API is up or down, AstroLab stays standing.

I really liked today’s APOD. That small lagoon reflecting the stars and the Milky Way arching overhead is beautiful. 🌌 (It's the second attach in this post)

more things here my man

Dealing with 429 errors (Quota Exceeded) while building a “Super MVP” on a free tier is a nightmare. 😤 Instead of crying about it, I built a Multi-tier Fallback

System to make the aggregator “unbreakable.”

• I built a central config.py that manages the intelligence flow:
• Primary: Gemini 3.1 Flash (its cheapest).
• Secondary: Automatic fallback to Gemini 2.5/2.0 if the primary quota hits a ceiling.
• Last Resort: OpenRouter integration using Gemma/Free models as a safety net.

I finally put the visual pipeline to the test. I took the Audio Overview generated in the research phase and overlaid the images using the logic I’ve been hardening over the last few sessions. Seeing the research actually turn into a timed video with visual assets is a huge win for the factory.

The resulting video is way too heavy to upload directly here, so I’ve made a folder available with the test file so you can see the output. It’s the first real look at how the system handles the transition from raw research to a structured visual storyboard.

So the video ended up a bit buggy and the transitions weren’t done well; the free quota of APIs I use had run out, so I was left with some pretty bad ones.

I used the Gemini CLI to help me debug the FFmpeg pipeline and speed up the generation of this test run. It saved me a lot of time on the mechanical parts of the code, especially while fine-tuning the sync between the audio and the overlays.

final research

Used Gemini CLI to debug the visual pipeline and accelerate the test video generation.

• feat: v0.6.8 - real bidirectional serial console (028be96)

It turned out that my haste to finish my OS made me not notice that I had some problems with the serial connection, and messing around with the JS and CSS broke some parts of the rendering because of that. I’m continuing here. I’ll probably leave v0.7 as the final version

I get happy because idirectional serial is finally stable, and seeing the ESP32 talk back in real-time

I compiled a C++ test file directly in my cloud environment, moved the .bin to my phone, and used the ESP32_Flash Android app to burn it into the ESP

What I noticed during testing: If you’re getting flash errors, disconnect any external components from the ESP first. They can draw too much current and corrupt the upload or kill the process. Keep it clean during the flash.

news:

• Bidirectional Serial: Full two-way conversation. Green text for incoming, yellow italics for outgoing. Essential for debugging on a small screen.
• Hardened Buffering: Fixed the logic to stitch fragmented packets together. No more UI flickering when the data gets heavy.

Testing more things in the DEMO version (for reviewers and other people who want to test it)

• I had to regenerate new tunnels with Cloudflare to have the link to the DEMO
• I fixed some errors
• I tried to bypass the Captcha blocking in PlayWright, I started a mini implementation of DuckDuckGo as a search engine (but I haven’t finished it yet)

As you can see, their system easily detects automated access…

• Revise project description for clarity (34ac15d)

I’m currently fixing a bug where the .env file refuses to load properly on Windows. It works fine on my Debian setup, but Windows is being picky with the file paths. I’m testing a fix using find_dotenv() to make sure the script locates the environment variables regardless of which folder it’s being called from.
I haven’t committed the .env file yet (obviously, security first), but I’m in the middle of refining the loading logic so it’s 100% cross-platform. I want this to be “plug and play” for anyone, whether they are on Linux, Termux, or Windows.

And this is my test n this session (the image below)

• refactor: resolve circular dependencies and implement research-to-video visual pipeline (9f3f517)

Problem with Circular Dependency

As VideoLM grew, my NestJS services started pointing at each other in a loop. The app wouldn’t even boot properly. I had to stop everything and refactor the core architecture to resolve these circular dependencies. It’s the kind of “invisible” engineering work that takes hours and doesn’t show up in the UI, but it’s what makes the system hardened and professional. No more “spaghetti code” holding back the factory.

Research-to-Video is Live:
The big win was implementing the Visual Pipeline. I finally connected the brain (Research Mode/NotebookLM) to the muscle/engine (FFmpeg).

The system now takes the factual deep-dive and automatically maps it into a 10-scene storyboard. It’s not just generating text anymore; it’s orchestrating how those facts are translated into visual scenes with Ken Burns effects and transitions. The bridge between raw data and a structured video is officially built.

• feat: implement research-to-storyboard orchestration bridge (035f6ae)

finished the logic to turn those dense NotebookLM results into actual YouTube-ready videos. The “Factory” is no longer just researching; it’s actually building the final product.

I say Technical Win:
I built a dynamic assembly logic that handles high-fidelity external audio. The pipeline now auto-generates 10 visual scenes based on the facts it finds, then uses FFmpeg to render everything with Ken Burns effects and smooth transitions.

Current:
I’ll be honest: I haven’t run a full end-to-end test yet. But I’ve been digging deep into the research and engine files, editing the core logic and using the CLI to debug the assembly process piece by piece. The structure is there, and with the CLI debugging shows the pipeline is ready to move.

• feat: v0.6.7 - THE SHIP - final UX polish, field guide and window motion (9e9814c)

This is the final push. I’ve spent the last few hours hardening the UI for the final ship. Since the physical hardware (The Nerve) is still stuck in transit, I made sure the “Digital Twin” is as close to a real workstation as possible.

The Field Guide (Built-in Docs):
I was tired of switching tabs to check my own documentation while testing on my phone. So, I built the Field Guide directly into the OS. It’s a built-in manual that lives in the index.html and is managed by os.js. Now, the instructions for the factory are always one click away. No more tabbing out in the middle of the bus ride.

Window Motion & Aesthetic Glow:
I added window-open and window-close animations in style.css. On a small mobile screen, windows just “appearing” is disorienting. The new scale and opacity transitions give you a sense of space—you see where the window is coming from. I also refined the scanline overlay and the neon glow. It’s that Absolute Cinema aesthetic I’ve been chasing since day one.

UX Hardening:

• Taskbar & Icons: Refined the hitboxes for the taskbar. When you’re using a touch screen with the Unexpected Keyboard (An Android keyboard that has PC-style keys that I use ) active, every pixel of space matters.
• Vanilla Logic: Cleaned up the window z-index handling in os.js to make sure the active process is always on top without flickering.

The Takeaway:
The hardware didn’t make it in time, but the software is 100% shippable. NerveOS is now a functional environment that I can actually use to monitor my other pipelines. The “Nervous System” is online and it feels solid.

I testing and researching how finish the MCP implemnet,and other things Here’s 10PM and I’ll rest. It’s the bedtime

Sorry for don’t explained certainly how I made and the things in the process like others posts

I managed to do it, guys, I’ve improved what I’ve been doing. They’re small things, but important.

Added a live log console to the web dashboard. Now I can see the heartbeat of the system—telemetry syncs and remote commands—happening in real-time. I prototyped the JS logging logic quickly, creating a solid diagnostic loop for the entire ecosystem. In addition to researching, studying, and reviewing MCP protocol documentation.

• feat: v0.6.6 - persistence layer, macro manager and notes sync (c0ff4e2)

The NerveOS now has a memory. It’s no longer just a session; it’s a permanent workstation.

News

Virtual FS Persistence: Every folder you create with mkdir and every file you touch is now saved to the browser’s storage. You can refresh, close the tab, or reboot—your data stays. 💾

Notes Auto-Sync: The Notes app is now fully integrated with the FS. Anything you type is saved in real-time to the virtual disk.
Macro Manager: Built a new app dedicated to hardware automation. One-tap scripts for WiFi scanning, OLED testing, and MCU reboots. It’s about making complex tasks fast.
Terminal History: Command history (up/down arrows) now persists between sessions. No more re-typing long serial commands.

Hey man, it’s going well, I think it’s almost finished. Just like I had thought a bit at the beginning of the project. But really at the end. Unfortunately, testing with the ESP won’t be possible because by the time The Nerve gets to me, Flavortown have will already be finished. But that’s it, I liked it.

• feat: v0.6.5 - real-time telemetry, hardware bridge and alert audio (c19fd10)

This session was about searching how implement the telemety and device link. For NerveOS try to listen.

What was implemented:

The Data Bridge: Replaced the Math.random() garbage with a real Serial parser. If the ESP32 sends a data packet, the OS displays it instantly.
Emergency Protocols: Added a temperature monitor. If the deck hits 75°C while I’m in the field, the UI goes red and the NerveAudio alert triggers. It’s not just an OS; it’s a diagnostic station.
NerveAudio Pro: Added a new ‘alert’ synth tone for critical system states.
UI Sync: The CPU graph now accurately reflects the hardware load the moment you hit ‘LINK’.

It turns out I haven’t received Blueprint approval yet. Therefore, I don’t have the hardware in hand and I have to conceptualize, research, and discuss with the AI ​​support systems I use how this will work when I have The Nerve here.

Ever since the first ship of VOICE-TASK-MASTER, I’ve been keeping a close eye on the feedback loop from the community and the reviewers. It became clear that while the core concept was solid, the distribution and some initial details needed immediate attention. I realized I had committed a classic mistake by forgetting to include the .crx build in the GitHub Releases section, which made installation a bit of a hurdle for some of you. This has been fixed, and the latest build is now live and accessible for anyone wanting to test the neural uplink without friction.

I’ve also been analyzing the comments regarding the UX and UI stability. I am already deep into the code refactoring the speech recognition logic to ensure that interim results are captured more accurately across different environments. Reading through the judge’s notes has been incredibly helpful; it’s clear that the project needs to feel less like a “Cyberpunk HUD” and more like a native extension of the Flavortown ecosystem. I am currently “cooking “ a total visual overhaul—moving away from generic neon styles to adopt the official Hack Club design tokens.

This phase is all about refining the ingredients. I am committed to turning every piece of feedback into a technical improvement. The v1.5.1 update is already in the works, focusing on making the tool feel professional, unobtrusive, and genuinely useful for the high-intensity workflow we all love here in the shipyard. Stay tuned, because the next ship is going to be massive (I hope, at least )

• feat: implement end-to-end NotebookLM research loop and persistence fix (9ac4354)

Today I finally finished the full lifecycle for the factual research. The system isn’t just shouting orders at NotebookLM anymore—it actually stays on the line, monitors the progress, and pulls the generated audio/video files back to the local server automatically.
I also spent some time fixing some annoying DB persistence bugs. The AI data was de-syncing from the user projects, but now everything is properly linked. It finally has “memory” and handles the artifact downloads on its own.
The factory is starting to feel solid.

• docs: rewrite README in English and update technical stack (52719d4)

Polished the dashboard’s visual identity and fixed some static asset routing issues that surfaced during the migration. Cleanup of the HTML/CSS structure. Everything now looks Absolute Cinema I’d say, even when I’m checking the dashboard on a mobile browser.

• feat: v0.6.4 - mobile mission control, terminal quick commands and devlog rewrite (9f4217a)

This session was all about making the OS a real tool for field use. If I’m away from the station, I need the phone to be a professional remote.

What was implemented:

Windows now automatically go fullscreen on mobile. No more dragging windows on a tiny screen—they behave like real apps now.
Taskbar is now thumb-friendly (70px height) and supports horizontal scrolling for app switching.
Desktop icons scaled up so you don’t need a stylus to click them.
Terminal Utility:
Added Quick Commands: A row of buttons (help, ls, status, clear) above the keyboard. Typing on mobile is annoying, so now the most common tasks are just one tap away.
Increased font size for better legibility in the field.
And Disabled CRT flicker animation on mobile to save battery and keep the interface snappy.

Writing a few things to continue in the web PC

This is in my PC:

I spent the last few sessions just fighting to get a decent DEMO ready for the reviewer. It’s one thing to run it locally, but making it stable for someone else is another story.

What I’ve been doing
Infrastructure: Had to swap a bunch of URLs and re-upload server.py. I’m using a Cloudflare tunnel with nohup now so the server stays alive even after I log off from the Web PC.

Screenshot Bug: Playwright was being a pain. Every time it took a print of the page to “see” what was happening, it would cut off the bottom half. The agent was basically blind to anything below the fold. I tweaked the settings so it shows almost everything now, but I still need to polish a few things to make it 100%.

And man when I writting this post appear images like emojis (this because I use the Spicetown extension). Taked a look liked this:

For Keeping the pipeline healthy in this session, critical I’d say. The factory was showing some cracks in the FFmpeg assembly logic. When you’re running complex filter_complex chains on a mobile ARM64 processor, things can get messy if the code isn’t 100% tight.

I spent approximately 30 minutes debugging the engine core with the CLI Fixed a broken loop in the render sequence that was causing frame drops. In this business, if the pipeline stops, the factory dies. Everything is back to 100% stability now. Ready for my tests

Another thing I found cool and am discovering more about is the formatting in .md files (which you can do in Flavortown posts). I saw that if you put two pairs of underscores (__) between words, they become underlined. If you use only one pair, they become italicized.

• feat: v0.6.3 - visual polish, terminal syntax highlighting and devlog update (2c89780)
• fix: v0.6.3 - fix boot sequence hang and restore syntax highlighting (8c5a723)

I forgot to write the V in the past devlog. This are the v0.6.3

Alright, I felt like the UI was a bit too “soft.” It needed more grit.

• Industrial Borders: Ripped out the rounded corners and went with sharp 4px borders. It looks way more like industrial hardware now.
• Deep Glassmorphism: Buffed the blur to and cranked the saturation. Windows finally pop against the background. ✨
• Terminal Glow: Added scanline textures and a subtle text-shadow to the terminal. It actually feels like a CRT now.
• Syntax Highlighting: The terminal now highlights commands, arguments (the ones with -), and paths in different colors. It’s subtle but makes a huge difference in “vibe.” I’ll say

The UI/UX needs testes and simple modifications (in certain times). Control de aesthetics with css and a few things.

Finally closed the gap between the TypeScript MCP Server and the FastAPI Hub. Mapping Zod schemas between TS and Python is a pain, so I used the Gemini CLI to speed up the protocol alignment. It cut the work in half, allowing external AI models to access the mobile hardware tools without breaking the communication.

• refactor: improve Discord UI with embeds and add profile hot-reload (324662c)

With the new UI I transformed the bot from basic text output to high-end Discord Embeds. It’s not just for looks; it’s about readability. I implemented a color-coded hierarchy: High Match (>75%) gets a vibrant green, while lower scores drop to amber and red. 🟢🟡🔴

The biggest technical win this session was the Profile Hot-Reloading in src/scorer.py. I refactored the AIScorer to re-read user_profile.md on every single request.

It happened that when I’m on the bus and realize I forgot to add FastAPI to my skills, I can just edit the markdown file on my phone and the bot adapts instantly. No restarts, no downtime.

• feat: implement active NotebookLM orchestration and source ingestion (82fc473)

Today I finally got the Research Mode orchestration to behave. It’s a huge jump for VideoLM—it’s not just a video pipeline anymore; it’s actually acting like a research agent.

The technical mess I had to fix:
The Node-Python Bridge: This was a nightmare. Getting NestJS to talk to the Python engine for NotebookLM while Google kept blocking auth in the cloud was driving me crazy. I ended up using a metadata.json to sync the session. It’s a bit of a workaround, but it stabilized the whole thing. Now the backend creates the notebook, injects the URLs/PDFs, and triggers the “Deep Dive” automatically.
SQLite Persistence: I was losing data because of how I was handling the database during crashes. I hardened the logic so each project now locks onto its official notebookId. No more losing the research data if the process restarts.

The Proof:
Ran a final test with two heavy links about AI and SaaS. The pipeline created the notebook, fed the IA, and started generating the factual podcast script without me touching anything. With a Artifact ID

• feat: NerveOS v0.6.3 - terminal v3.0 with syntax highlighting, dynamic prompts and enhanced command parsing (10d6ae2)

Upgraded the terminal to v3.0. I implemented basic syntax highlighting so I can differentiate between commands and arguments at a glance. It makes the ‘Absolute Cinema’ UI feel much more like a developer tool.
Also updated the prompt to show the current working directory from the mock filesystem. Efficiency is increasing.

I’m walking to finish and ship the project. I’ll go! 🚀🎉

• fix(core): ensure .env loads correctly on Windows and remove email from package metadata (79a57e3)
  to
• fix(ux): improve offline mode messaging and clarify quiz fetching (85edc32)

I went into astrolab/quiz.py and changed the UX text. Instead of just “Fetching APOD”, it now explicitly tells the user why it’s doing that:
"Fetching today's NASA APOD data to use as study context for your quiz..."

It’s a tiny string change, but it completely fixes the mental model for the user. They now understand the quiz is dynamically generated from today’s picture.

I also toned down the terminal output colors and emojis a bit. Sometimes less is more when you want a tool to feel like a real developer utility rather than a toy.

I’m still checking, testing, and trying to make sure everything is working correctly and that there won’t be any errors in parts of the system/user experience.

• feat: NerveOS v0.6.2 - real-time process manager, ‘ps’ terminal command and centralized process tracking (f62ffde)

v0.6.2 - Process Manager Update
This session was all about system control. I realized that as the number of apps grew, I needed a way to monitor and manage them all in one place. I built a Process Manager that tracks every open window.

The tricky part was ensuring the process list stayed in sync with the actual window states. I had to refactor the openWindow and closeWindow functions to update a central STATE.processes Map. I also had to implement a real-time refresh logic so the uptime counters for each process would update every second without lagging the UI.

It getting very special for me…
_It turns out I know more back and getting this far with the project is really cool, I enjoying the proces :) _

• fix(core): resolve pathing errors and UI color value mismatch (caeb79a)

Spent the last few hours moving the engine from a generic generator to something more personal. The main focus was the new Creator Branding Kit.

The Branding System

I implemented a modular branding folder structure. Now you can drop your own logos, define specific brand colors in a JSON file, and set a custom “style prompt” for the AI.

• The engine reads these configs and injects the style directly into Gemini before the script is even written.
• Updated the main CLI with a profile selector. Now I can switch between different creator identities right at launch.

Debugging & Cleanup

It wasn’t all smooth sailing. I ran into a few annoying bugs:

• Had a ValueError in the main menu because I messed up the ANSI color unpacking (forgot a variable for RED, so the whole UI crashed).
• Encountered a ModuleNotFoundError when running the AI writer standalone. Fixed it by forcing the project root into sys.path.

• feat: NerveOS v0.6.1 - visual file explorer, note integration and folder navigation (082200d)

v0.6.1 - Explorer

Alright, this was a big step for the filesystem. Up until now, the mock files were only accessible via terminal commands like ls and cd. I decided it was time for a visual layer.

The Challenges:
The main difficulty was mapping a nested JavaScript object (the mock FS) to a dynamic grid of icons. I had to ensure that clicking a folder correctly updated the STATE.explorerDir and re-rendered the UI without losing track of where the user was.

What was implemented:
File Explorer App: A new visual app to browse directories like /bin, /usr, and /dev.
Navigation Logic: Added a “Back” button functionality and breadcrumb path tracking.
Notes Integration: This is the most useful part. If you click a .txt file in the explorer, the system automatically opens the Notes app and loads that file’s content into the editor.
UI Polish: Icons change based on file type (folders vs files) and have a clean hover effect that matches the

Testing because I lost my Devlog hours and they all accumulated here… I don’t even know how long I was supposed to schedule this Devlog. I started keeping an eye on this project because of the previous error, and now there’s a new one… but yesterday

I worked a bit more in the integratio with python nlm. Tested the system with cookies from my PC browser because I started the development iof this project in the Cloud and continued here (I think I’ll finish in the same way)

• feat(hub): implement ESP32 hardware bridge v0.8.0 (c05cfd4)
• feat(arch): implement remote hardware provisioning and captive portal (9d332f0)

Today was a major turning point. I moved beyond just code and finally got the physical hardware integrated into the ecosystem.

The goal was simple but tricky: make the ESP32 “smart” enough to join the network without me having to hardcode WiFi passwords or IP addresses every time something changes. I implemented a system where the device now handles its own connection. If it can’t find a network, it just asks for one through a mobile portal.

The most satisfying part was seeing the “On-Air” light actually work. Now, whenever I start a new video project on the Dashboard, a physical red light on my desk turns on automatically.

I’m writing this devlog in a rush. My laptop battery died, and since I’m editing this post on my phone (there’s no extension here to add commit changelogs), it ended up looking a bit hazy.

Summary: I spent about two weeks trying to ship this project, but Hack Club does not accept project demos on platforms that do not have a kind of “forever” free quota. Type of Render and Railway that I was using. I found out Yesterday I learned that Hack Club could provide servers for Hack Club members, so I signed up and was approved right away. I spent the whole day testing this with MediaPipe Tasks for Web and after a long time and with the help of Gemini CLI, I finally reached the point of deploying the project.

Unfortunately, Playwright doesn’t work because the server’s datacenter IP address is reporting thatSince it’s not from a regular user, it ends up blocking web requests.

• feat: NerveOS v0.4.4 - bidirectional hardware control (serial write), oled/reboot terminal commands and macro actions UI (8ea62da)
• feat: NerveOS v0.6.0 - synthetic audio engine (Web Audio API), terminal autocomplete (Tab), desktop shortcuts and filesystem ops (0ba286d)

This was a massive session. NerveOS finally has audio. I built a synthetic sound engine from scratch using the Web Audio API to generate real-time cyberpunk SFX without using external files. Added tab-completion to the terminal and desktop shortcuts to make the environment feel like a complete OS. The terminal now supports file operations like ‘mkdir’ and ‘touch’ on the mock filesystem.

It’s been a natural next step after bringing the aggregator to Discord. With the /opportunities command already working, the bot can now go further: users can paste any opportunity title or description and get an instant AI analysis on demand.
Making the bot more interactive
The new /analyze slash command was added to bot.py. It accepts free text input, creates a lightweight mock opportunity, runs it through the existing AIScorer class, and returns a clean Discord embed.
The embed shows:

A Match Score (0-100%, with orange highlight when >70%)
A clear Rationale explaining why the opportunity fits (or doesn’t) the user profile
Title and shortened description for context

To keep the bot responsive, the heavy AI scoring is offloaded with loop.run_in_executor and the interaction is deferred, following the same pattern used in the previous Discord integration.

Testing because I lost my Devlog hours and they all accumulated here… this Devlog should have been around 5 hours, but yesterday I tried to do the Devlog and hackatime.hackclub.com was giving a server error (error 500), so it couldn’t make any posts or register time with wakatime.
From 5h go to 45h

Changes

• feat: implement research ingestion logic and secure controller (d100291a)
• docs: standardize technical documentation and add NLM integration tests (65e06a5

Main changes I made:

• Created a new ResearchController with JWT protection for the endpoints to add sources and trigger research.
• Updated the ResearchService to handle adding source URLs, update project metadata, change status to “researching”, and start the NotebookLM audio/video overview generation.
• Added proper validation so only valid lists of URLs can be sent and improved error handling for the whole flow.

While working on this part, I recently changed the NotebookLM CLI tool I was planning to use. I went back to YouTube videos and GitHub to find the original repo again, and ended up discovering another one: https://github.com/jacob-bd/notebooklm-mcp-cli. This one is written in Python. Since I already know Python, I prefer it here. It also looks more complete with extra features for managing notebooks, sources, and generating studio content.

I had already been using NotebookLM for some time and I think it’s a really good tool for studying. Now that I’m studying Computer Engineering, I believe I’ll use it a lot. The video overviews it creates are especially interesting and high quality. That’s why I thought integrating these features directly into VideoLM would be cool — it should bring Google-level quality to the videos we generate. So far, the initial parts of this integration are done and working well.

• Final cleanup of README and confirm Gemini 3 fallback router (84a9f86)
  to
• Fix: migrate to Stealth 2026 context manager (51ef0f7)

PWA Project Lifecycle (v0.7.0)

Upgraded the Hub to a production-grade management tool with native Android integration.

• PWA Implementation: Added manifest and service worker support. The Hub is now installable as a native Android app via Chrome, providing a standalone mobile interface.
• Lifecycle Management: Implemented PATCH/DELETE endpoints and UI actions. Users can now update project status or clear the production queue directly from the Dashboard.
• Unified Orchestration: Verified ‘start-all.py’ compatibility. The orchestrator seamlessly manages the new FastAPI backend and mobile agent lifecycle.

• Fix hand tracking toggle, Render headless mode, and Playwright screenshot extraction (42a9636)
  to
• Refactor search to use direct Playwright with –no-sandbox for Render stability (d1637ed)

I refactored the browser search flow to stop relying on the MCP bridge for simple navigation and screenshots.

Replaced the old mcp_bridge.call_tool("browser_navigate") + screenshot logic with a dedicated capture_screenshot(url) helper that uses direct Playwright:

Key changes in server.py:

• New async function with chromium.launch(headless=True, args=["--no-sandbox", ...])
• Applied playwright_stealth + proper wait_until="networkidle" + 5s buffer for heavy JS
• Screenshot as JPEG quality 60, returned as clean base64
• Updated both manual search and HOMES_SEARCH_BROWSER paths
• Improved error messages and status updates (“STARTING_PLAYWRIGHT”, “SEARCH_COMPLETE”)

The flow is now simpler, faster to debug, and much more reliable on Render/cloud deployments where sandbox and shared memory can cause issues.

Quick but focused session after classes. Seeing the screenshot arrive cleanly in the HUD without MCP complexity felt like removing unnecessary weight. The tactical interface stays responsive while the agent does real web work.

I still need to work on and improve all of this. I’ll have to add better logs to the system and Playwright screen, especially (they don’t all appear currently). Also, when I was preparing to make this Devlog, I received a notification on Slack that the reviewer rejected my ship, saying that rendering wasn’t allowed and that I should use something like Vercel or Cloudflare Pages… I didn’t understand because this is more backend-related, and he wanted deployment on sites that work with static archs

• feat: add hand-tracking toggle and real-time HUD movement logic (921aaaf)
  to
• feat: enable dual-source vision (cloud + local) for remote tracking (4744461)

Today I tried to made the vision pipeline way more reliable by implementing dual-source frame acquisition in vision.py.

What changed:

• Primary source: frames from cloud/WebSocket frame_queue
• Automatic fallback: if no cloud frame arrives within 10ms, switches to local cv2.VideoCapture(0)
• Added source tracking (“CLOUD” or “LOCAL”) and updated overlay text to show it clearly alongside gesture name
• Kept full MediaPipe HandLandmarker processing unchanged
• Safe cleanup: webcam is only released if it was actually opened

The gesture loop now stays alive even if the remote browser connection drops temporarily — perfect for long stealth automation sessions or when running in mixed environments.

Focused session after classes. Seeing the overlay switch smoothly between SRC: CLOUD and SRC: LOCAL while gestures kept working felt like removing the last weak link in the chain. No more vision dying when the stealth agent goes off-screen.

Combined with the recent persistent stealth Perplexity tools, MCP bridge, and robust demo/fallback HUD, OmniLab is becoming a true resilient local agent.

And also, as you can see, the model was in a mess when I went to prepare the Devlog. So it didn’t even receive the form that was sent. But this is fully functional.

Unfortunately, the HUD is being disobedient… I couldn’t get it to actually follow the hand gestures. Locally, things are going well, but to reflect in the render, I need to push the changes to the remote and wait for the modifications to build, which delays testing and debugging a bit. And the URL search does ot work

• chore: remove devlog directory and stop tracking logs (739a6a8)
• feat(cli): add brand selector and dynamic banner to main menu (0ebef0a)

new things for the brand in the app. I prepared the directories and oyher things to setup all system of branding for the processed videos in with the system. Fix a a part of the pre-assets used in the assembly

Main changes:

• I aded the brand selector in the menu. For the user pick the prefered identity for the video
• Enhanced the menu
• Search the local of the error with the video assemby

I’m in a hurry so I didn’t do such a complete overview this time. I didn’t detail the formatting or important things I did, changed, etc.

• feat: Add Discord Bot integration for Converge sidequest 🤖 (c5a681e)

Discord Integration for Converge Sidequest

It’s been a busy few days. While the Telegram bot was working fine, I realized that to truly close the loop for the Converge sidequest, I needed to bring the aggregator to where the community actually hangs out: Discord.

Shifting to Discord

I implemented the Discord integration using discord.py. Instead of traditional prefix commands, I went with Slash Commands (/opportunities) using the CommandTree. It makes the UX much cleaner for the end user.

The biggest challenge wasn’t the UI, but how the bot handles the workload.

Since the bot has to scrape multiple sources (Devpost, MLH, TabNews) and then wait for the Gemini API to score them, these tasks are “blocking.” In a Discord bot, if you run a heavy scraping function directly inside an async command, the entire bot freezes until it’s done.

To fix this, I used loop.run_in_executor. This allows the bot to:
Receive the command.
Trigger the “thinking…” state (interaction.response.defer).
Offload the heavy scraping/scoring to a separate thread.
Post the results back once they are ready without ever disconnecting from Discord’s gateway.

On Telegram, I was mostly using plain text. For Discord, I took advantage of Embeds. Now, each opportunity shows:

• A clear Match Score (0-100%).
• The Rationale (Why the AI thinks this fits my profile).
• Links and tags in a structured format.

I’ve also updated the environment handling to support both Telegram and Discord simultaneously. The project is now reaching a stable milestone

I get happy for complete this part for the sidequest and because I got a new skill of dev:)

• refactor: implement user-based project filtering & route protection (0da0eed)
• feat: implement research infrastructure for source ingestion (d096fa1)

Research Infrastructure and NotebookLM Integration Foundation

The project gained a new research layer with the addition of source ingestion infrastructure. This allows the system to receive and store external sources (such as URLs or text) for each project and introduces a dedicated research module.

Main changes included:

• Added a ResearchModule and ResearchService to handle source management and research tasks.
• Extended the Project entity to support a list of sources and a new “researching” status.
• Implemented basic methods to add sources and start a NotebookLM research process.

Recently, while watching videos on YouTube and exploring open-source projects on GitHub, the author discovered the nlm project, a command-line interface for Google’s NotebookLM. I had already been using NotebookLM for some time and found it to be an excellent tool for studying and organizing information. Now that I’m is studying Computer Engineering, NotebookLM is expected to be used even more frequently. The video overviews produced by NotebookLM are particularly interesting and high-quality.

This led to the idea of integrating NotebookLM features directly into AI Video Factory. Having NotebookLM’s capabilities — especially the ability to generate deep, well-structured audio overviews — inside the system would bring Google-level quality to the generated videos. So far, the initial parts of this integration have been implemented and are working well.

• feat: implement browser-side camera capture for Render deployment (02abd48)
• feat: implement full cloud-vision pipeline for Render (clean code) (c5ecb5d)

making this devlog for carry the commits changelogs (If I use other machine or my phone it’s don’t get availiable, because this changelog feature is an extension (Chrome/Firefox)

Here I made changes to change how the deployment on Render accessed the processed images and kept testing the system. I was trying to make the HUD work like locally (in this case there will be an annoying delay anyway. The distance, latency, and processing from the user’s browser to the Render server cause this…)
The capture of the frames had not yet been implemented here. I think somewhere in the middle of the edits I ended up getting lost and didn’t make many improvements in this part of the system.
In this part I used the Gemini CLI to try to explain to myself and debug how to make the system work on Render. Helping it helped, but I felt I could have done more… kind of didn’t get anywhere

• Delete vtm_v1.4.0.zip (c4111fc)
• Add files via upload (40a407e)

• I’m basically working for the reship.
  For some reason, it seems the zip file in the repo was old. I tweaked a few things, made commits, and prepared to reship and make sure things are where they’re supposed to be.

Go to this page for view the Kitchen Mode from the extension Flavortown Kitchen

Take a look on the attached images in this post. (I flashed the photo from my phone because when I activate the printscreen app the pop-up of the extension 'hide'

• fix(hub): restore dashboard styling and add live logs console (4cb8e6e)

for only send this Devlog with the commit changelog. It’s from the Spicetown browser extension. I’ll take the image from the Google Keep printed in the smartphone, before attached in Keep site (in my phone). Finally rescue this in Keep site on the PC

Changes:
Restored the Cyberpunk Dashboard styling and added real-time activity feedback.

• UI Restoration: Fixed a pathing error that disconnected the CSS during the FastAPI migration. The interface now renders correctly with full styling.
• Live Logging: Integrated a scrollable console into the Dashboard for instant feedback on telemetry syncs and project creation.

• feat: implement SaaS identity foundation & hardened multipart production pipeline (ac49650)

The project took a major step toward becoming a real SaaS application with the addition of a user authentication system. This foundation allows users to create accounts, log in, and keeps their generations secure and separated.

Main changes included:

• Implemented JWT-based authentication with registration and login endpoints.
• Protected the AI and video generation routes so only logged-in users can access them.
• Added support for users with basic quota tracking.
• Hardened multipart file uploads with higher size limits and better validation to handle background music, audio tracks, and multiple images reliably.
• Increased server timeouts and payload limits to support longer video rendering without interruptions.

These updates make the system more professional and prepare the ground for paid plans and user management in the future.

Early in the project, Docker and DevOps concepts needed significant learning and adjustment. Considerable time was also spent refining the FFmpeg configuration for reliable video assembly.

AI served as an accelerated learning companion rather than a replacement for hands-on work. Like in JWT system and learning this pratices

• refactor: stabilize MCP bridge and pivot branding to HOMES (1ca3baa)
  to
• feat: implement persistent stealth automation and Perplexity search engine (b40e296)

Today I pushed the automation layer to the next level with full persistent stealth capabilities using Playwright.

Created a suite of tools that reuse real Chrome sessions (launch_persistent_context + user_data_dir=./.playwright_data) and apply playwright_stealth to bypass detection. Focused on Perplexity AI as a powerful external brain:

New scripts added:

• stealth_agent.py — headless/off-screen stealth navigation with anti-detection flags
• perplexity_agent.py — persistent login flow (manual Gmail step + 180s wait)
• find_history.py — searches and extracts OmniLab-related threads from sidebar
• perplexity_chat.py — automates follow-up questions in existing threads
• Helper scripts for layout inspection and screenshot validation

Intense after-class session. Seeing the stealth agent open Perplexity, find old OmniLab threads, and send a clean follow-up without triggering any blocks felt like unlocking a new superpower. The HUD can now decide to query Perplexity semantically via MCP and bring rich answers back to me.

Combined with the recent MCP bridge and robust demo mode, OmniLab is evolving into a true local command center that can use the entire web intelligently and feed my HOMES pipeline with high-quality data. Next: wire Perplexity actions directly into the gesture/voice flow and add mock versions for flawless demos.

** P.S. I used AI to structure this post. I organized and went through the things I had worked on and made a briefing of the things. Also, to test the scripts and some tests I used CLI to improve my errors and accelerate this test part.**

Persistent Storage: Implemented a JSON-based database layer. Video projects and system telemetry are now automatically saved and restored on server restart, ensuring zero data loss.

• Architectural Resilience: Improved error handling within the FastAPI lifecycle to manage local file I/O operations safely in the Termux environment.

I’m almost certain I won’t use widgets anymore. I even studied a bit and it worked to use KWGT, but the information wasn’t fully updated when using the phone normally. I also thought about it more and realized that what he was going to show I can deliver with a page/dashboard on the HUB’s localhost.

Transformed the Hub into a functional AI Video Orchestrator using a Manager-Worker architecture.

Engineering Updates

• Project Factory: Implemented a FastAPI-based queue system. The Hub now manages video project lifecycles (Pending -> Completed).
• Mobile Worker Bridge: Refactored the Mobile Agent to poll the Hub for tasks, establishing a live production synchronization loop.
• Pure Architecture: Purged all legacy code and simulation noise. The repository is now a clean micro-service hub.