This week’s reflection isn’t about code style or syntax. It’s about how we respond when the review hits closer to home. When the silence after a merge says more than the comments. When critique stops stinging because you’ve already seen it in yourself.

Day 141 to 147 explored:

• Staying present when critique lands
• Letting friction sharpen you
• Leading without defense
• Listening for what silence reveals
• You act on what you’ve already internalized.

These aren’t just habits. They’re posture. The kind that changes how you show up on the commit and in the room.

If you’re building more than features, if you’re building yourself, this week’s reflection is for you.

Read the full post on Substack
Week 21 – Feedback as Growth

Legal added two conditions before I touched it. Nobody may predict the winners, and we have to reproduce the exact draw six months later if anyone contests it.

Those two conditions fight each other. Reproducible means a seed. A seed published before the draw lets anybody compute all ten names in advance. It took most of an afternoon to satisfy both, and the mistakes along the way are the interesting part.

Method 1: Python 3.11.1 — draw now, publish the seed afterwards

The trick that settled it: mint a 64-bit seed from the OS entropy pool at the moment you run the draw, use it, then publish it after the winners go out. Until that instant nobody can know the outcome, because secrets.randbits(64) reads from /dev/urandom. Afterwards anyone with the CSV and the recorded seed replays the identical list.

# draw_winners.py — Python 3.11.1
import csv, json, random, secrets
from datetime import datetime, timezone

rows = list(csv.DictReader(open("registrants.csv")))

seen = {}
for row in rows:                          # last registration wins
    seen[row["email"].strip().lower()] = row
pool = sorted(seen.values(), key=lambda r: int(r["registration_id"]))

seed = secrets.randbits(64)
rng = random.Random(seed)
winners = rng.sample(pool, 10)

print(f"rows {len(rows)} -> unique people {len(pool)}")
print(f"seed {seed}")
for n, w in enumerate(winners, 1):
    print(f"{n:2d}. {w['registration_id']:>5}  {w['email']}")

with open("draw-record.json", "w") as f:
    json.dump({"drawn_at": datetime.now(timezone.utc).isoformat(),
               "seed": seed,
               "pool_size": len(pool),
               "winners": [w["email"] for w in winners]}, f, indent=2)

My run:

rows 8453 -> unique people 7912
seed 6803436325215821286
 1.  5218  hugo.1007@proton.me
 2.  2644  jonas.2949@fastmail.com
 3.  3899  omar.4274@fastmail.com
 4.  7623  ines.5768@acme.io
 5.  5788  grace.1486@outlook.com
 6.  3998  quentin.1796@outlook.com
 7.  5236  kira.3290@gmail.com
 8.  6944  chloe.4702@proton.me
 9.  7197  hugo.4107@proton.me
10.  6047  rosa.2557@proton.me

Two details worth copying. The dedupe runs before the draw, keyed on the lowercased email with the last registration winning, so someone who filled the form twice still gets one entry. And random.sample draws without replacement, unlike random.choices, which is pitfall 3.

Replaying six months later is short enough to paste into a dispute email:

import json, random
record = json.load(open("draw-record.json"))
pool = build_pool("registrants.csv")       # same dedupe as above
print([w["email"] for w in random.Random(record["seed"]).sample(pool, 10)] == record["winners"])

Seeding also answers the “who verified this” question in a way that logging ten email addresses never does. If you would rather skip seeding, secrets.choice(pool) per winner is fine too, but keep the printed list as your evidence since there is no number to replay.

Method 2: Node 22.13.1 — crypto.randomInt with a partial Fisher-Yates

Same job with zero dependencies. crypto.randomInt(min, max) draws from the CSPRNG and handles rejection sampling internally, so unlike crypto.randomBytes(4).readUInt32BE() % n it does not skew the low end of the range.

// drawWinners.mjs — Node 22.13.1
import { readFileSync } from "node:fs";
import { randomInt } from "node:crypto";

const lines = readFileSync("registrants.csv", "utf8").trim().split("n").slice(1);
const byEmail = new Map();
for (const line of lines) {
  const [id, email] = line.split(",");
  byEmail.set(email.trim().toLowerCase(), id);       // last one wins
}
const pool = [...byEmail.entries()].sort((a, b) => Number(a[1]) - Number(b[1]));

function pick(pool, k) {
  const remaining = pool.slice();
  const out = [];
  for (let i = 0; i < k; i++) {
    const j = randomInt(i, remaining.length);        // crypto-backed, no modulo bias
    [remaining[i], remaining[j]] = [remaining[j], remaining[i]];
    out.push(remaining[i]);
  }
  return out;
}

console.log(`rows: ${lines.length} unique: ${pool.length}`);
for (const [n, [email, id]] of pick(pool, 10).entries()) {
  console.log(`${String(n + 1).padStart(2)}. ${id.padStart(5)}  ${email}`);
}

On the same CSV:

rows: 8453 unique: 7912
 1.  1514  farid.7145@gmail.com
 2.  7382  sven.4378@acme.io
 3.  7162  kira.3630@gmail.com
 4.  7934  quentin.4656@outlook.com
 5.  3338  quentin.3296@outlook.com
 6.  1595  tara.3459@fastmail.com
 7.  8364  ana.7180@gmail.com
 8.  4519  dmitri.1763@acme.io
 9.  4791  grace.8866@outlook.com
10.  6326  grace.6346@outlook.com

Note that pick consumes only k values and then stops, so the cost stays flat whether the pool holds thousands of rows or millions.

What Node will not give you is a seedable, reproducible CSPRNG stream. Math.random() is seeded once per context and cannot be rewound, so replaying an old draw in JS means rolling your own PRNG on top of a randomInt-generated seed, or simply doing the draw elsewhere.

Method 3: when you just want ten numbers right now

Plenty of the time nobody needs a script. Meetup raffle with 200 tickets, splitting a workshop into four groups live on a call, seeding a few fixture values while writing tests. I open this browser-based random picker, set the range to 1 through 7912, switch on no-duplicates, ask for 10, and copy them into the sheet.

Everything runs client-side, so the registrant list never travels to a server. That matters more than it sounds: most giveaway exports contain emails you have no permission to push through somebody else’s API. Dedupe and sorting are checkboxes there rather than lines you can forget, which makes the third pitfall impossible on that path.

It also covers the boring asks: seat numbers, ticket stubs, ten integers between 1 and 100 to pad a test fixture. For those I use the random number generator at utilvy and never open an editor.

Pitfalls I actually hit

1. The old results page leaked its seed in 10 ms

Before rewriting anything I read the script marketing had been using for previous draws. It was a MINSTD generator seeded from the clock:

let state = BigInt(Date.now());
const next = () => {
  state = (state * 48271n) % 2147483647n;      // Lehmer / MINSTD
  return Number(state) / 2147483647;
};

Once three consecutive outputs are visible anywhere, whether on a results page or inside sequential promo codes, the seed falls out by brute force over plausible millisecond values:

observed: [ 3285, 2106, 5622 ]
recovered seed (epoch ms): 1793239041039  in 10.1 ms

Ten milliseconds, and every later number from that page was already determined when it was written. MDN puts it plainly: Math.random() does not provide cryptographically secure random numbers. randomInt and secrets do.

2. Modulo bias is real, and usually far smaller than you fear

The classic shape:

idx = int.from_bytes(os.urandom(1), "big") % 100

A byte spans 0 to 255, which is not a multiple of 100, so 0 through 55 are reachable three ways and 56 through 99 two ways. Across 200,000 draws the low group totalled 131,253 against an expected 131,250, averaging 2,344 hits per slot against 1,562. The busiest slot (46) came up 2,461 times and the quietest (92) only 1,456. That gap is 1.5001x, precisely 3/2.

Scale it to the real pool and it nearly disappears. 2**32 % 8453 leaves a remainder of 6,449, so the first 6,449 people get 508,100 chances each while everyone else gets 508,099. An edge of 0.000197%.

My takeaway after measuring both ends: call the library function because it costs nothing, and stop suspecting % of rigging a draw once the pool climbs past a few hundred thousand.

3. Ten winners can be nine people

My first draft used random.choices(pool, k=10), which samples with replacement. Over 10,000 simulated draws, 55 of them announced the same email twice. The same test with random.sample on the deduped pool produced zero.

Reach for a set to fix it and Python refuses outright:

>>> random.sample(set(emails), 10)
TypeError: Population must be a sequence.  For dicts or sets, use sorted(d).

Set support was deprecated in 3.9 and removed in 3.11, and yes, the double space after the period is in the real message. Sort first and it behaves:

random.sample(sorted(set(emails)), 10)

The same trap exists one step upstream. My file had 8,453 rows for 7,912 people, so drawing from rows lets even a correct winner list hand two entries to one registrant. Dedupe the people before you draw them.

Short version

More free browser-based utilities at utilvy.com

Weaviate’s anonymous default makes exposure discovery worth a second look

Weaviate is a vector database with REST and GraphQL interfaces. Its documentation states that anonymous access is enabled by default in Docker and that requests without explicit authentication run as the anonymous user. The setting is intended for development and evaluation. A deployment that keeps the default after it begins holding production data has an authorization problem regardless of the number of internet matches.

A count-only ZoomEye measurement on 2026-10-29 returned 59 matches for title="Weaviate" and 0 for app="Weaviate". Both used sub_type=all, page 1, and page size 1. The title result is the selected discovery query. These are matching observations, not confirmed anonymous deployments or exposed records. The zero application result is not proof that Weaviate is absent from the internet.

Check authentication and authorization separately

Weaviate documentation lists API key, OpenID Connect, and anonymous access as authentication modes. When anonymous access is on, a request without credentials is authenticated as user: anonymous. Authorization then determines what that user can do. If authentication is disabled or an anonymous user has broad permissions, the database is reachable by a larger population than the owner intended.

RBAC is the recommended production authorization model. Roles can constrain access at the collection, tenant, and operation level. Authentication identifies a principal; RBAC decides which classes, objects, and tenants that principal can read or change. A deployment that enables an API key but gives every key root-level access still has a broad authorization boundary.

Review the configuration variables that control anonymous access, API keys, OIDC, and RBAC together. The authorization guide warns that undifferentiated access is suitable only for development or a trusted single-user environment. For a multi-tenant service, test a user against a collection and tenant that belongs to another user. Do not infer tenant isolation from collection naming.

Use product evidence with care

The title query can identify a page that mentions Weaviate, a documentation site, a login screen, or a service operator. Validate the candidate through an owned hostname, a product route, or a cloud asset record. The application field returned zero, so a title-only candidate needs more corroboration before an analyst treats it as a Weaviate API.

A reverse proxy can hide the backend product fingerprint while still forwarding the API. That is one reason a zero app count should not be used as a negative inventory control. Use internal configuration management and cloud discovery as complementary sources. If an external endpoint is discovered, compare it with the expected listener, authentication provider, and network boundary.

Record the query as a measurement, not a statement of affectedness. The match count can change when pages are updated or when ZoomEye’s observations change. A useful record keeps the exact query, date, result, unit, and scope, then links it to the owner and the internal test result.

A practical Weaviate review

For each owned cluster, confirm AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED is false in production unless an explicit public-read use case exists. Enable API key or OIDC authentication and configure RBAC. Remove the root key from client applications and give each service a role scoped to its collections and tenants.

Test anonymous requests and low-privilege requests against read, write, delete, backup, and schema operations. Verify that a user with access to one collection cannot see the existence of another, or at least cannot read its objects or metadata. Check the health and metrics endpoints separately. If they are intentionally internal, keep them off the public listener.

Add monitoring for anonymous requests, authentication failures, unexpected schema changes, and bulk reads. A request count is not proof of misuse, but a sudden rise in anonymous activity can give an owner a reason to inspect the deployment. If anonymous access is enabled by accident, turn it off and rotate any credentials that were reachable from the same network.

Weaviate’s default is easy to carry from a demo into production. Discovery helps find candidates, but the decisive evidence is the running authentication and authorization configuration. A 59-match title set is not a vulnerability count. It is a reason to ask whether any owned cluster still behaves like a development instance.

References

• ZoomEye count-only observation: title=”Weaviate”
• Weaviate: Authentication
• Weaviate: Authentication and authorization
• Weaviate: Docker installation

So I built a small n8n workflow where the model gets a fixed list of category ids and may answer with one of them or null. Anything else is treated as a failure.

How it runs

Form POST -> Webhook (name, email, company, message)
  -> Normalize; no valid email -> HTTP 400, nothing logged
  -> LLM sees: category ids + one-line descriptions, and the enquiry
  -> Code node: is the reply exactly one of my ids?
       yes -> that category
       no (null, unknown id, a sentence, API error) -> needs_human
  -> Append one row to Google Sheets
  -> Webhook answers 200 with the category

The category list lives in one Code node called Settings (edit me), something like sales_inquiry, support, partnership, job_application, spam, other, each with a short description and a priority. The prompt and the check both read from that node, so you can’t end up with a prompt that mentions a category the check doesn’t know.

The check is a few lines of code

The model’s reply gets trimmed, lowercased, and stripped of quotes and a trailing full stop. "Partnership." therefore still counts as partnership. After that it has to match an id exactly. A reply like “This looks like a partnership request” fails, even though it contains a valid id, because I don’t want to guess what the model meant. It goes to needs_human with the reason written in a check_notes column.

An HTTP 500 from the model API goes down the same path. The webhook still answers 200 and the row is still written, so a flaky API doesn’t lose enquiries.

One more thing that tripped me up in an earlier workflow: form text can contain {name} or {{ $json.x }}, and n8n’s LangChain nodes treat braces as template syntax. The message needs escaping before it goes into the prompt. In this workflow, text with braces is stored in the sheet exactly as sent.

Testing

I ran it on a real n8n 1.123.87 instance with local stand-ins for the OpenAI and Google Sheets APIs, and 17 checks passed: correct categories logged for sales and support enquiries, form-encoded and JSON bodies, null / invented id / sentence / HTTP 500 all ending up as needs_human, braces surviving, missing or invalid emails getting a 400 with no row and no model call, exactly one row per valid request, and no other hosts contacted.

What I haven’t tested: a real model and a real sheet. The checks show that a correct answer gets through and a bad one doesn’t, not how well a given model sorts your enquiries. The webhook also has no authentication or dedupe, so add those before you put it on a public form.

Get it

This workflow is in a free bundle with two others (a WhatsApp FAQ bot that can only send stored answers, and a B2B cold-email drafter that never sends anything): 3 free n8n AI workflows, pay what you want, $0 is fine.

If you need the WhatsApp side done properly, with signature checks, dedupe, opt-out and human handoff, the full kit is $19.

• Book: Ship It — the pragmatic startup tech stack
• Also by me: Thinking in Go (2-book series) — Complete Guide to Go Programming + Hexagonal Architecture in Go
• My project: Hermes IDE | GitHub — an IDE for developers who ship with Claude Code and other AI coding tools
• Me: xgabriel.com | GitHub

If you build Android apps with Claude Code or Codex, you have probably been running two windows: the agent in a terminal, and Android Studio next to it for the emulator, Logcat and previews. On October 28, at Android Dev Summit, Google moved both of those pieces toward the agent you already use.

First, Android Studio itself now hosts outside agents. In Google’s words, “Android Studio now supports over 40 ACP-compatible coding agents directly inside Android Studio through Bring Your Own Agent and the open Agent Client Protocol (ACP).” The same post says the feature “is now stable in today’s release of Android Studio Rabbit 2.”

Second, and easier to miss: Google’s Android CLI now installs as an official plugin for Claude Code, Codex and Antigravity. That one doesn’t need the IDE open at all.

What shipped in Android Studio Rabbit 2

Bring Your Own Agent (BYOA) is a marketplace inside the IDE. Google’s instructions: “open Settings > Tools > AI > Agents to browse and install agents from the marketplace. You can install more than one and switch between them as you work” (Android Developers Blog).

The Rabbit 2 release post names four of the 40-plus agents: Claude Agent, Codex from OpenAI, Junie and Google Antigravity, and says any “ACP compliant agent” works. The Decoder reports they can run at the same time.

The pitch is that the agent gets the IDE’s knowledge of your project. Google lists “a deep understanding of your project structure and build, symbol resolution, Compose Preview rendering, the Emulator, Logcat, and more” (Android Developers Blog).

The plumbing is the Agent Client Protocol, which “standardizes communication between code editors/IDEs and coding agents.” Local agents run as subprocesses of the editor and talk “via JSON-RPC over stdio,” per the ACP site. That is why one integration can cover 40 agents: Android Studio speaks the protocol, and any agent that speaks ACP, natively or through an adapter, can plug in.

Rabbit 2 also adds Change Review. You “start a review session from pending agent changes or the Git changes window, and Android Studio generates a report of potential issues,” and you can call it with a /review command from the agent tool window (Android Developers Blog).

One protocol, many agents: Android Studio speaks ACP, and each agent plugs in through it.

The part that skips the IDE: Android CLI as an agent plugin

Google describes Android CLI as working “in any terminal, with any agent harness, and in your CI pipelines, so your agents can build, run, and debug Android apps autonomously” (Android Developers Blog).

The plugin docs give these commands. For Claude Code, from your terminal:

claude plugin marketplace add android/android-cli-plugin
claude plugin install android-cli@android-cli-plugin

For Codex:

codex plugin marketplace add android/android-cli-plugin
codex plugin add android-cli@android-cli-plugin

Note the Codex verb is add, not install, in the second line. Antigravity gets agy plugin install android-cli-plugin@antigravity-plugins-official.

The plugin lives in a public android/android-cli-plugin repo under Apache-2.0. Its README says the repo “holds the plugin only,” which matters: the plugin is a skill that teaches the agent how to use Android CLI, and the CLI itself is a separate install. You still install Android CLI from the downloads page, then, per the CLI docs:

android update
android init

android init installs the android-cli skill. The docs also say you can turn off data collection with the --no-metrics flag. If your agent runs in CI, decide that on purpose and pass the flag where the pipeline calls the tool. They also describe a ~/.androidrc file that applies flags automatically, one per line; they don’t say whether --no-metrics works there, so check before you rely on it.

What the agent gets, per the plugin docs: it can “create projects, manage virtual devices, inspect live UI layouts, run Journeys, and search the official Android Knowledge Base.” The summit post adds android preview, which “renders your Compose Previews without needing an emulator or the IDE,” and android device remote, which can “provision a real physical device from a secure Google device lab.”

Read the speed numbers as Google’s numbers

The headline figure is this sentence: “In our internal testing, agents that used android preview completed UI tasks 77% faster while using up to 3x fewer tokens” (Android Developers Blog). For memory leaks, Google says that with Android CLI’s LeakCanary tool “the most capable models ran this process almost 2x faster while using up to 25% lesser tokens.” The Decoder reports that A/B test used Claude Opus 5.5.

Both are vendor tests on vendor-picked tasks, and the post doesn’t publish the task set. The direction is believable. An agent that can render a preview instead of booting an emulator and screenshotting it should spend fewer turns. Measure the gain on your own app before you quote it.

android preview renders Compose Previews from the terminal, so the agent can check UI without booting an emulator.

What to check before you switch it on

The privacy guarantees in the release post are written for Gemini Enterprise. The Rabbit 2 post says that for Gemini Enterprise, source code and workspace context are never retained or used to train global foundation models, and it adds audit logging and central admin policy. It doesn’t say those terms extend to Claude Agent or Codex. A third-party agent inside Android Studio is still that vendor’s agent, on that vendor’s terms. Check your Anthropic or OpenAI plan’s data terms before you turn either one on.

Sign-in is per agent. Google’s setup step is to “authenticate” (Rabbit 2 post), with no detail on what each agent requires. Expect each one to use its own account and its own usage limits.

Remote devices and preview rendering give an agent more reach. If a tool can provision a physical device in Google’s lab, put it behind an approval prompt, the same as git push. Keep your agent’s permission mode where it is now, and let it ask before it runs android device remote.

I haven’t run Rabbit 2 or the plugin myself. Everything above is from Google’s October 28 posts and its Android CLI docs.

Running it from Hermes IDE

I build Hermes IDE, so weigh this with that in mind. Hermes runs Claude Code and Codex in a real terminal, “exactly as it would anywhere else, so a vendor’s new commands and modes work in Hermes the day they ship” (Hermes README). The plugin installs into the agent, not the editor, so the same two claude plugin or codex plugin lines are what you’d type in a Hermes session.

What Hermes adds is a separate hermes/<task> branch and worktree per task, so you could give Claude Code and Codex the same Android ticket and compare. It does not render Compose Previews or host an emulator. For those, Android Studio’s own BYOA panel is the tool built for the job. Hermes is free, on macOS, Windows and Linux, and not affiliated with Google, Anthropic or OpenAI.

Codex on orders-types and Claude Code on orders-api, side by side in Hermes 2.3.4, each in its own hermes/ worktree, with status, context use, cost and branch in the sidebar.

So the question for Android teams is which surface you want the agent in. Do you want it inside Android Studio, next to Logcat, or in a terminal where the CLI plugin gives it the same tools? Tell me which one you’re trying first.

If this was useful

An agent that can build, preview and run your Android app from a terminal is an agent that can do it in CI too. Ship It is about that whole stretch between localhost and production for a small team: hosting, CI/CD, auth, payments and monitoring, so the pipeline the agent lands in is one you trust. If you want to try the CLI plugin in a real session, Hermes IDE is free and runs Claude Code and Codex side by side.

When tasks are split across lists, calendars, and documents, teams spend time rebuilding context instead of moving work forward. A useful task management system should make it easy to capture work, clarify ownership and deadlines, and keep tasks connected to the information needed to complete them.

To choose one, start with the work your team needs to coordinate—not the AI feature list. Map a representative workflow, identify the structure and governance it requires, then test whether a tool supports it without adding unnecessary administration.

1. Classify the work before comparing tools

Personal task apps tend to emphasize fast entry and reminders. Product and engineering teams may also need dependencies, custom statuses, planning views, reporting, and repeatable workflows. Cross-functional teams may need shared goals and workload visibility; teams with calendar overload may need help protecting time.

Write down the requirements that apply to your work. A useful starting set is:

• How tasks enter the system and how priorities are set.
• Who owns each task, and how deadlines and dependencies are represented.
• Which views are needed for planning and status reporting.
• Whether tasks need to connect to documents, research, or other reference material.
• What permissions, roles, and shared standards the organization requires.
• Whether the system must support a particular deployment model.

This separates a need for calendar scheduling or personal reminders from a need for structured project execution. Those are different problems, and one product may not solve both.

2. Check what the AI actually assists with

Useful assistance should reduce a specific kind of work: identifying priorities, summarizing progress, capturing tasks, or reducing scheduling effort. Check whether suggestions preserve clear ownership and deadlines. For team use, shared context, permissions, and reliable reporting matter alongside generated recommendations.

Also distinguish calendar automation from project workflow support. Motion, for example, schedules task blocks and reschedules them when meetings or deadlines change. Reclaim.ai schedules habits, recurring tasks, and focus periods around existing calendar commitments. Both address time allocation; neither description implies detailed issue relationships or customized delivery workflows.

3. Evaluate structure, governance, and deployment

For complex work, check whether the system can represent the team’s actual process. Relevant controls may include custom fields and statuses, issue types and layouts, relationships between work items, planning views, reporting, and automation. If several teams need shared standards but different working methods, examine role-based permissions and hierarchical governance.

Confirm deployment requirements early. The comparison below records the deployment options and AI readiness labels reported for each product in the source material; it is a starting point for evaluation, not a substitute for verifying current requirements with the vendor.

Compare tools by the problem they address

Match the tool to the workflow

For structured product and delivery work

ONES.com is described as a project and knowledge management platform where AI agents can work within workflows. Teams can configure fields, statuses, issue types, layouts, link types, and workflows. Agile planning, collaboration, reporting, and automation support delivery work. Test management and CI/CD capabilities are also available when needs extend beyond task tracking.

This breadth can require more configuration than a personal task list. Teams should establish governance standards before creating many custom workflows. The listed deployment options are Cloud, On-Premise, Private Cloud, and Air-gapped.

For engineering issue cycles

Linear focuses on issue tracking, development cycles, roadmaps, and engineering integrations. It suits teams already working with software delivery concepts. Teams coordinating research, business operations, or extensive non-engineering knowledge may need additional systems or broader configuration options.

For cross-functional planning

Asana connects tasks with projects, goals, timelines, and workload views. Its AI assistance can help summarize work and surface planning information. Consistent project data and operating habits make this kind of planning more useful; the model may feel heavier for individual task management.

For highly configurable workspaces

ClickUp offers multiple views, hierarchies, fields, templates, time-tracking options, and reporting configurations. Its AI features can support drafting, summarization, and routine project communication. The number of choices makes a clear information architecture important before adding fields, views, or automations.

For tasks closely tied to documentation

Notion combines pages, databases, documentation, and task views. It fits work where actions are closely connected to briefs, notes, research, and other written context. Many workflows depend on users designing and maintaining the underlying databases; teams needing stricter delivery controls may prefer a purpose-built project system.

For personal task capture and calendar control

Todoist emphasizes quick entry through natural-language descriptions, due dates, labels, filters, and recurring items. It is aimed at maintaining a personal list with minimal setup; teams that need rich dependencies or shared delivery reporting may need more structure. Things organizes personal projects, areas, checklists, tags, and repeating tasks across Apple devices, rather than providing broad team coordination.

Motion turns tasks into scheduled calendar blocks and moves them when meetings or deadlines change. Reclaim.ai schedules habits, recurring tasks, and focus periods around calendar commitments. Both depend on calendar information for their time-planning role.

For existing Microsoft 365 users

Microsoft To Do with Copilot supports personal lists, reminders, and task capture within the Microsoft environment. It is positioned for individual follow-through and lightweight coordination; teams with dependencies, custom workflows, or detailed project reporting may need a more specialized platform.

4. Run a representative workflow test

Before adopting a tool, test it with a real example rather than an empty workspace. Include intake, prioritization, ownership, dependencies, status reporting, and completion. If relevant, also test permissions, shared context, calendar changes, and the deployment requirements identified earlier.

1. Enter a task through the same intake path your team expects to use.
2. Set its priority, owner, deadline, and any required dependencies.
3. Move it through the statuses and planning views the team needs.
4. Check whether reporting communicates progress and blockers clearly.
5. Review what happens when a meeting, deadline, or dependency changes.
6. Confirm that the task remains connected to the documents or knowledge needed to complete it.

Use the test to decide whether the tool reduces coordination work or simply creates another place to enter tasks. If the workflow requires extensive customization, assess the configuration and governance effort as part of the decision.

Choose based on the level of structure required

Calendar-focused tools address scheduling and focus time. Personal task apps prioritize quick capture and reminders. Engineering issue trackers, cross-functional planning tools, configurable workspaces, and document-centered systems each organize a different kind of work.

The right choice is the one that fits the complexity of the workflow, required deployment model, and governance needs. Test those requirements using actual work before committing to a system.

optimize_agent_stack (new in lantern-works-deals-mcp 0.3.6, MIT) parses the description with keywords and regex (no LLM), then picks the cheapest option with a cited price for each component among tracked providers. Every line has the math, the vendor’s pricing URL and when the price was checked. If no price is cited for a component, it says so and doesn’t guess.

Try it

uvx lantern-works-deals-mcp   # stdio MCP server, 6 read-only tools, no API key

Or use the browser version: https://thelanternworks.com/stack/?utm_source=devto&utm_medium=post&utm_campaign=stack-optimizer

There’s also an OpenAI Agents SDK example: https://github.com/connormatthewdouglas/agent-work-stack-deals/tree/main/examples/stack-optimizer

Real output (PyPI 0.3.6, run Oct 28, 2026)

tools: compare_deals, compare_gpu_prices, get_deal, optimize_agent_stack, optimize_stack, search_deals
job: scrapes 20k JS pages/month via 5 GB residential proxies, 3k search queries, summarizes with an LLM, budget $300/mo
parsed components: scraping, proxy, llm_api, search
  scraping: ZenRows Launch, $69.0/mo [priced], 20,000 x 5 = 100,000 credits; within 250,000 included at $69/mo, checked 2026-10-27T02:54:00-04:00, https://www.zenrows.com/pricing
  proxy: 9Proxy Residential (per GB), $3.4/mo [priced], $0/mo incl. 0 + 5 x $0.68 per 1 extra, checked 2026-10-27T02:54:00-04:00, https://9proxy.com/pricing  (referral link)
  llm_api: Groq Free plan with documented model rate limits (RPM/RPD/TPM) in Groq console docs, $0.0/mo [entry_price], free tier ($0), checked 2026-10-27T01:45:00-04:00, https://console.groq.com/docs/rate-limits
  search: Exa Starter credits + pay as you go, $4/mo [priced], $0/mo incl. 2,500 + 1 x $4 per 1,000 extra, checked 2026-10-27T02:54:00-04:00, https://exa.ai/pricing  (referral link)
$69.00 (scraping) + $3.40 (proxy) + $0.00 (llm_api) + $4.00 (search) = $76.40/mo (complete)
within budget: True

job: serve a 13B model for 40 GPU hours, send 5k emails, budget $150/mo
parsed components: gpu, email
  gpu: RunPod RTX A6000 (Community Cloud), $13.2/mo [priced], $0.33/hr x 40 h, checked 2026-10-28T16:43:09+00:00, https://www.runpod.io/pricing  (referral link; manual signup only)
  email: SendPulse Basic (free), $0.0/mo [priced], within 12,000 included at $0/mo, checked 2026-10-27T02:54:00-04:00, https://sendpulse.com/prices/smtp  (referral link)
$13.20 (gpu) + $0.00 (email) = $13.20/mo (complete)
within budget: True

A few things to notice:

• The numbers show their work: “20,000 x 5 = 100,000 credits; within 250,000 included at $69/mo”.
• The LLM line is entry_price. That’s the cheapest cited entry plan (a free tier), and real usage may need a bigger plan.
• “Cheapest” means cheapest among tracked providers. A vendor we don’t track may cost less, and the full JSON lists providers that aren’t priced.
• The 13B line filters GPUs by a stated rule: 13 x 2 bytes (FP16) x 1.2 = 31.2 GB VRAM on one GPU for inference. Quantized models need less; full fine-tuning needs several times more, so this estimate is for serving, not training.
• RunPod is flagged manual_signup_only: a human has to create the account (the vendor’s terms ban automated signups).
• GPU rates are re-checked daily, so the RunPod line may differ when you run it (this one was checked 2026-10-28, 12:43 PM ET). The other prices were checked 2026-10-27.
• Prices are monthly list prices before tax. Check the vendor page before you pay for anything.

Disclosure

Disclosure: some result links returned by the server are referral links. They’re marked affiliate: true with a referral_disclosure (lines tagged “(referral link)” above), and affiliate status isn’t a ranking factor. The source_url is always the vendor’s own pricing page.

Repo: https://github.com/connormatthewdouglas/agent-work-stack-deals

GPU Unlock project’s published benchmarks show substantial improvements in selected mathematical operations on the RTX 3090 Ti. Results vary by numerical format, demonstrating why the headline performance increase should not be treated as a universal speed boost.

The results indicate that the biggest improvements occur in specific compute-intensive operations. They do not mean that every AI application will run nearly twice as fast.

Real-World AI Image Generation Gets Up to 60% Faster

The most relevant results for everyday AI users come from tests using ComfyUI, a popular interface for image-generation workflows.

An RTX 3090 Ti owner reported the following improvements after applying GPU Unlock:

• MOSS-Image SFT using BF16: 58.6% higher throughput.
• Qwen-Image 2.1 Turbo using BF16: 57.2% higher throughput.
• Z-Image Turbo using BF16: 56.1% higher throughput.
• MOSS-Image SFT using INT8: just 0.3% higher throughput.

These results suggest that AI image generation can benefit considerably when its workload relies on the affected tensor operations. However, the tests are community-reported benchmarks on specific hardware and software configurations, rather than guarantees of performance for every user.
The minimal INT8 improvement also illustrates an important limitation: workloads using different numerical formats may see little or no benefit.

Can GPU Unlock Make Local LLMs Run Faster?

GPU Unlock may also improve some large language model (LLM) workloads, particularly prompt processing, where a model evaluates input tokens in parallel.

Reported tests using vLLM showed improvements of approximately 33% in prompt processing and inference throughput on an RTX 3090. Other reported results across Ampere GPUs showed improvements of 14% to 36% in LLM prefill performance.

However, token generation speed often remains largely unchanged.
The reason is that generating tokens one at a time is frequently limited by memory bandwidth rather than raw Tensor Core computing power. Since GPU Unlock does not increase VRAM bandwidth or capacity, it cannot eliminate this bottleneck.

For developers running local AI models, the practical benefit will therefore depend on the model architecture, quantization, inference software and workload.

Which NVIDIA RTX 30 Series GPUs Are Supported?

The project lists support for GPU families GA102, GA103, GA104 and GA106, covering a substantial portion of the RTX 30 Series lineup.
Potentially compatible models include the RTX 3090 Ti, RTX 3090, RTX 3080 and other Ampere-based cards. However, support is not guaranteed for every board or configuration, and some reported compatibility tests have failed to deliver the expected improvement.

The main implementation uses a Linux kernel module that runs before the NVIDIA driver initializes. Because it changes hardware settings during initialization, installation requires more technical knowledge than a typical graphics driver update.

An experimental Windows implementation has also been reported, but it uses a different approach and should not be confused with a generally supported Windows release.

Does GPU Unlock Improve Gaming Performance?

There is currently no convincing evidence that GPU Unlock delivers comparable improvements in gaming frame rates.

Although technologies such as NVIDIA DLSS use Tensor Cores, gaming performance depends on many other factors, including graphics workloads, memory bandwidth, CPU performance and the specific instructions used by a game.

The reported gains primarily concern AI computing and selected matrix operations. Players should not assume that installing the tool will increase FPS by 60% or improve every DLSS-enabled title.

Security Risks and Limitations to Consider

GPU Unlock remains an experimental, unofficial modification. Changes to low-level hardware initialization can cause system instability, failed boots, GPU hangs or data corruption, depending on the implementation and hardware.

Before considering it, users should:

1. Review the project’s source code and installation instructions.
2. Confirm that their exact GPU model is supported.
3. Back up important data and maintain a recovery method.
4. Avoid installing unverified binaries or running commands from untrusted sources.
5. Understand that an unsupported configuration could leave the system unable to boot normally.

Users who depend on their computers for production workloads should be particularly cautious. The potential performance gains may not justify the stability risks on a machine that needs to remain reliable.

Final Thoughts

GPU Unlock could give NVIDIA RTX 30 Series owners a meaningful performance boost for certain AI workloads without purchasing a newer graphics card. Community tests show gains of up to 60% in selected image-generation tasks, while some tensor compute benchmarks improve by considerably more.
However, these gains depend on the workload, numerical format and hardware configuration. The project does not increase VRAM capacity, memory bandwidth or gaming performance automatically, and its experimental nature introduces stability risks.

For AI developers and enthusiasts running local image-generation models, GPU Unlock is an interesting project to watch. For everyone else, the safest approach is to wait for broader compatibility testing and more independent benchmarks before changing low-level GPU settings.

قبل أي شيء آخر: توقف عن الحفظ والتنزيل والنسخ والتثبيت على ذلك القرص. كل ملف جديد يمكن أن يهبط على القطاعات نفسها التي لا يزال ملفك المحذوف يشغلها. هذا الدليل مرتّب بحيث تأتي الخطوات الآمنة أولاً — اتبعه من الأعلى إلى الأسفل.

• ماذا يحدث فعلاً عند تفريغ سلة المحذوفات

• القاعدة الأولى: توقف عن الكتابة على ذلك القرص

• فحوص بدقيقتين قبل أن تفحص بأي برنامج

• ما يستطيع ويندوز أن يفعله بنفسه

• القرص الصلب مقابل SSD: لماذا الخطأ نفسه يكلّف أكثر على SSD

• كيف تحكم على برنامج الاستعادة قبل أن تدفع

• نِسب نجاح واقعية بحسب الحالة

• قائمة مراجعة للاستعادة، بالترتيب الصحيح

ماذا يحدث فعلاً عند تفريغ سلة المحذوفات

في أي قسم بنظام NTFS، يتكوّن الملف من شيئين: سجل في جدول الملفات الرئيسي (MFT) يقول «هذه البايتات تُكوّن ملف report.xlsx، وتبدأ من المجموعة X»، والمجموعات نفسها — مخزّنة فيزيائياً على أقراص القرص الصلب أو في شرائح ذاكرة SSD.

نقل الملف إلى سلة المحذوفات لا يمسّ أياً منهما. كل ما يفعله ويندوز أنه يبدّل اسم السجل ويضعه في مجلد مخفي اسمه $Recycle.Bin في جذر كل قرص. لا شيء يُفقد، وهذا سرّ أن الاسترجاع من السلة يكون فورياً ودقيقاً.

أما تفريغ السلة فأمر مختلف. يحذف ويندوز هذه السجلات ويعيد المجموعات إلى مساحة القرص الحرّة. البايتات لا تزال موجودة فيزيائياً؛ لكن لم يعد أحد يطالب بها، وصار من حق النظام أن يعطي هذه المجموعات بالذات لأول ملف يطلب مساحة.

إذن لدينا فشلان منفصلان، ويستحقّان أن تفصلهما عن بعضهما:

• الخريطة اختفت. هذا قابل للاسترجاع. برامج الاستعادة تمرّ على القسم كما هو، تتعرّف على بصمات الملفات وبقايا الفهارس، وتعيد بناء الخريطة — عادةً مع اسم الملف الأصلي إن كان النظام NTFS، وأحياناً باسم مُولَّد إذا كان السجل نفسه قد تضرّر.

• البايتات كُتب فوقها. هذا غير قابل للاسترجاع. لا ببرنامج ولا بأي وسيلة ولا بأي ثمن. اللحظة التي تهبط فيها بيانات جديدة على تلك المجموعات، يتوقف ما كان فيها عن الوجود.

كل ما يلي في هذا الدليل يخدم شيئاً واحداً: منع الحالة الثانية بينما تعمل على الأولى.

القاعدة الأولى: توقف عن الكتابة على ذلك القرص

إن قرأت قسماً واحداً فليكن هذا. نسبة النجاح تتحدد في أول خمس عشرة دقيقة، ولا شيء تثبّته لاحقاً يُصلح كتابةً طائشة.

افعل هذا الآن

• توقف عن الحفظ والتنزيل والنسخ والطباعة. أغلق المتصفح إن استطعت — ذاكرته المؤقتة وحدها تكتب ميجابايتات في الدقيقة.

• حدّد مكان حفظ الملفات المستعادة: فلاش ميموري، أو قرص خارجي، أو جهاز آخر، أو رفعها إلى السحابة. ولا تعُد بها أبداً إلى القرص نفسه الذي تسترجع منه.

• إن كانت الملفات على قرص النظام (عادةً C:) فاعرف أن ويندوز نفسه يكتب بلا توقف: ملف الصفحات، ملف السبات، القياس عن بُعد، مزامنة OneDrive، تنزيلات التحديثات، فهرس البحث. الجهاز الساكن أمامك ليس قرصاً ساكناً.

• إن كانت البيانات مما لا يُعوَّض، أوقف الجهاز إيقافاً صحيحاً وأعد تشغيله من قرص آخر أو من فلاشة إنقاذ. هذا القرار الواحد أثمن من أي برنامج تشتريه.

ولا تفعل هذا

• لا تثبّت برنامج استعادة على القرص المُتضرّر. هذه أكثر الطرق شيوعاً لفقدان ملفاتك بيدك. استخدم نسخة محمولة موضوعة على قرص مختلف، أو ثبّت البرنامج على جهاز ثانٍ وافحص القرص منه.

• لا تشغّل «تنظيف القرص» ولا «إلغاء التجزئة والتحسين» ولا chkdsk /f. هذه أدوات إصلاح؛ وهي تكتب في البيانات الوصفية ذاتها التي تحاول قراءتها.

• لا تفرمِت «لأن ويندوز طلب ذلك». إذا كان القرص قد بدأ يُظهر أخطاء، فالتهيئة تحوّل حالة صعبة إلى حالة مستحيلة.

• لا تُرتّب الملفات الناجية بسحبها إلى مجلد آخر على نفس القسم. كل نقل هو كتابة.

فحوص بدقيقتين قبل أن تفحص بأي برنامج

قرابة ثلث من يصلون إلى هذه الصفحة لا يحتاج أصلاً إلى برنامج استعادة — يحتاج إلى أن ينظر في المكان الثاني الصحيح. ابدأ بهذه؛ لا تكلف شيئاً ولا تكتب شيئاً.

• سلة محذوفات أخرى. لكل قرص مجلد $Recycle.Bin مخفي خاص به، ولكل مستخدم ويندوز مثله. إن كان الملف من قرص ثانٍ، أو حُذف من حساب آخر، فقد يكون لا يزال هناك سليماً.

• الملف نفسه عبر خدمة سحابية. إن كان المجلد داخل OneDrive أو Google Drive أو Dropbox، فملفك على الأرجح له حياة ثانية في سلة المحذوفات الخاصة بالخدمة أو في سجل إصداراتها. الحسابات المجانية تحتفظ عادةً بالملفات المحذوفة نحو ٣٠ يوماً قبل الحذف النهائي — تحقّق من الخدمة نفسها بدل تصديق الرقم. هذه أكثر حالة تُحلّ في دقيقتين، ولذلك جاءت قبل كل برنامج في هذه القائمة.

• الإصدارات السابقة. انقر بزر الماوس الأيمن على المجلد الذي كان فيه الملف ← خصائص ← الإصدارات السابقة. إن كانت حماية النظام مفعّلة قبل الحذف، فقد تجد نسخاً أقدم من المجلد، ويمكنك فتحها أو نسخها خارجاً بلا أي برنامج.

• محفوظات الملفات أو نسخة ويندوز الاحتياطية. إن كان أيّهما مفعّلاً يوماً ما، فاستعد النسخة من هناك بدل الفحص: النسخة الاحتياطية تعطيك الملف كاملاً، والفحص قد يعطيك أجزاءً منه.

• النسخ التي نسيت أنها موجودة. ملفات الاسترداد التلقائي في أوفيس، المجلدات المؤقتة، النسخة التي أرسلتها إلى زميل بالبريد، الإصدار الذي لا يزال في ذاكرة تنزيلات تطبيق محادثة. قبل أن تحارب من أجل النسخة المحذوفة، تحقّق هل نسخة أخرى لا تزال حيّة.

• دوّن الوقائع. اسم الملف بدقّة، مسار المجلد الكامل، حرف القرص، متى حُذف تقريباً، وكيف — تفريغ السلة، Shift+Delete، تهيئة، أم «اختفى فقط». ستحتاج هذه الخمسة، والرابع منها هو الذي يحرّك نسبة النجاح أكثر من غيره.

ما يستطيع ويندوز أن يفعله بنفسه

ثلاث طرق مدمجة، مرتّبة من الأسهل إلى الأكثر جهداً. الأوليّتان لا تكتبان شيئاً على القرص، والثالثة أداة استعادة من سطر الأوامر تصدرها مايكروسوفت.

استعادة الإصدارات السابقة

خصائص ← الإصدارات السابقة على المجلد الحاوي، أو ابحث في قائمة ابدأ عن «استعادة ملفاتك باستخدام محفوظات الملفات». لا تعمل إلا إن كانت الحماية مفعّلة قبل الحذف — وكثير من الأجهزة تُباع وهي معطّلة. تستحق الفحص مع ذلك، لأنها حين تعمل تكون فورية.

أداة Windows File Recovery (winfr)

من إصدار مايكروسوفت، مجّانية، تُثبَّت من متجر Microsoft، وتعمل من موجه أوامر بصلاحيات مدير. لا واجهة رسومية لها. ثبّتها على قرص مختلف عن الذي تسترجع منه، وإلا كتبت فوق ما جئت تبحث عنه.

winfr C: D: /regular /n UsersاسمكDocumentsreport.xlsx
winfr C: D: /extensive /n *.jpg
winfr E: D: /extensive /n Photos2025*
الترتيب دائماً المصدر أولاً ثم الوجهة، ولا بُدّ أن تكون الوجهة قرصاً آخر. وضعان يهمّانك:

• /regular يقرأ سجلات ملفات NTFS ويعيد عادةً الأسماء الأصلية وبنية المجلدات. هذا أول ما تجرّبه على قرص NTFS سليم.

• /extensive يعمل على بصمات الملفات. يجد بيانات لم يعد يعرفها جدول الملفات، لكن الملفات المستعادة تفقد غالباً أسماءها الأصلية وتخرج مجمّعة بحسب النوع.

ملاحظتان عمليّتان: أسماء المفاتيح تغيّرت بين الإصدارات، فشغّل winfr /? واستخدم ما يطبعه إصدارك. ولا توجد معاينة — كل شيء يُكتب أولاً وتُفرزه بعد ذلك، وهذا يعني أنك تحتاج مساحة حرّة على الوجهة تقارب ما تأمل استرجاعه.

القرص الصلب مقابل SSD: لماذا الخطأ نفسه يكلّف أكثر على SSD

هذا ما تتجاهله أغلب الأدلة، وهو سبب أن شخصين يرتكبان الخطأ نفسه تماماً ويخرجان بنتيجتين مختلفتين كلّ الاختلاف.

على القرص الصلب الميكانيكي، البيانات المحذوفة تبقى مكانها حتى يُكتب فوقها شيء آخر. ونسبة النجاح تهبط ببطء — معظمه بسبب استمرارك في استخدام الجهاز — وملفات حُذفت قبل أسابيع تعود أحياناً بشكل يفاجئك.

أما في القرص SSD فثمّة آلية إضافية: TRIM. عندما تُحرَّر المجموعات، يخبر نظام التشغيل القرص أن «هذه الصفحات غير مستخدمة»، ويمكن لجمع القمامة في المتحكّم أن يمحوها فيزيائياً في أول لحظة فراغ — وغالباً بينما يبدو لك الجهاز ساكناً. وما إن تُمحى المجموعة، تذهب محتوياتها قبل أن تنهي قراءة هذه الجملة.

أمران يجعلان استعادة SSD أصعب من ذلك:

• التشفير. في الأقراص المشفّرة عتادياً، وفي أي جهاز يعمل عليه BitLocker أو تشفير الجهاز، التخلص من مادة المفتاح الخاصة بمجموعة يكفي وحده لجعل محتوياتها غير مقروءة للأبد. دون أن تتغيّر أي ظروف أخرى، هذا وحده يحيل حالةً قابلة للاسترجاع إلى حالة ميؤوس منها.

• تسوية التآكل. العنوان المنطقي الذي يُكتب إليه ليس الموقع الفيزيائي المُستخدم، لذا افتراض «لم يُكتب هناك شيء مؤخراً» أضعف بكثير من حاله على القرص الميكانيكي.

الخلاصة العملية: على قرص SSD السرعة أهمّ من البرنامج. أوقف الجهاز، أو انقل القرص إلى جهاز آخر، أو افحصه للقراءة فقط من فلاشة إنقاذ — واعتبر أي شيء مضى عليه أكثر من بضع ساعات حالةً صعبة.

كيف تحكم على برنامج الاستعادة قبل أن تدفع

البرنامج أقلّ أهمية بكثير من الترتيب الذي تعمل به. لكن بين البرامج فرقٌ حقيقي بين ما يُبنى للمشغّلين وما يُبنى لقُمَع البيع، وأربعة فحوص تفصل بينهما.

• هل يفحص للقراءة فقط؟ أول وظيفة لأداة الاستعادة ألّا تلمس القرص. أي برنامج يريد أن «يُصلح» أو «يحسّن» أو «يفحص» القرص قبل أن يريك النتيجة، يُغلق.

• هل يمكن تشغيله من غير القرص المُتضرّر؟ النسخ المحمولة ووسائط الإنقاذ ليست ترفاً. التثبيت على القرص الذي تسترجع منه هو أكثر خطوة مُدمِّرة في هذه الصفحة.

• هل يريك ما وجده قبل الدفع؟ فحص لا يقول شيئاً حتى تُدخل مفتاح الترخيص يعرض عليك شراء وعد. الأدوات الجادّة تعرض أسماء الملفات وأحجامها ومعايناتها أولاً.

• هل هي صادقة في الإخفاق؟ «يستعيد ١٠٠٪ من ملفاتك» إعلان تجاري. الأدوات الحقيقية تتحدّث عن أنظمة الملفات وعن الاستعادة الجزئية وعن حالات لا يعود فيها شيء — لأن تلك الحالات موجودة فعلاً.

أمران أصغر يستحقّان التحقّق: هل الترخيص يغطّي حالتك (كثير من الأدوات مجانية للاستخدام الشخصي فقط)، وهل سياسة الاسترداد حقيقية أم مجرّد نموذج تواصل.

الخيارات المجانية تعمل فعلاً في الحالات البسيطة — أداة تعمل بالبصمات مثل PhotoRec تستخرج صور JPEG من بطاقة ذاكرة مُهيّأة، وغالباً دون الأسماء الأصلية. والذي لا تعطيك إياه الأدوات المجانية عادةً هو ترتيب عمليات يمكن الدفاع عنه، وهذا هو ما يحسم النتيجة حين لا تكون الحالة بسيطة.

نِسب نجاح واقعية بحسب الحالة

قائمة مراجعة للاستعادة، بالترتيب الصحيح

اطبعها، أو أبقِ هذه الصفحة مفتوحة على هاتف — لا على الجهاز المُتضرّر.

• أوقف الكتابة. أغلق كل ما يحفظ تلقائياً.

• دوّن: اسم الملف، المجلد، حرف القرص، وقت الحذف التقريبي، وكيفية الحذف.

• تحقّق أولاً من سلة المحذوفات في الخدمة السحابية ومن سجل الإصدارات.

• تحقّق من الإصدارات السابقة ومحفوظات الملفات وأي نسخة احتياطية.

• حدّد الوجهة: قرص فيزيائي مختلف.

• إن كانت البيانات مما لا يُعوَّض، أوقف الجهاز وأقلع من فلاشة إنقاذ بدلاً من ذلك.

• افحص للقراءة فقط، وتعمل من ذلك الوسط الآخر.

• استرجع إلى القرص الآخر — ولا تُعِد شيئاً إلى المصدر.

• افتح الملفات المستعادة وتحقّق من حجمها الحقيقي قبل أن تحذف أي شيء.

• فقط بعد التأكد من كل شيء في مكان آخر: أعد تشغيل TRIM إن كنت عطّلته، ودع التحديثات تعمل، وواصل.

• وبعدها، فعّل محفوظات الملفات أو أي نسخ احتياطي ستتركه يعمل فعلاً. الوقاية من كل حالة في هذه الصفحة أرخص من محاولة استعادتها.

الأسئلة الشائعة

في كثير من الحالات نعم — لكن ليس لأن السلة لا تزال تحتفظ بها. تفريغها يُحرّر المساحة التي كان الملف يشغلها، والبيانات نفسها تبقى حتى يُكتب مكانها شيء آخر. وكم كُتب منذ ذلك الحين هو تقريباً القصة كلها.

لا توجد مدة ثابتة. على قرص ميكانيكي لا يمسّه أحد، أسابيع ممكنة. على قرص نظام في جهاز يُستخدم يومياً، ساعات. على قرص SSD وقد عمل TRIM، ربما دقائق. والجواب الصادق أن الساعة تجري بالكتابة لا بأيام التقويم.

ليس تلقائياً، لكن النسبة أقلّ بكثير والنافذة أقصر بكثير. إن كان الملف قد حُذف قبل دقائق، فتحرّك الآن: أوقف الجهاز، أو افحصه للقراءة فقط من وسط آخر. وإن كان القرص قد عمل بشكل عادي ليوماً كاملاً، فافترض أن البيانات ذهبت في مجملها.

لا. التثبيت يكتب ميجابايتات على القرص الذي تحاول إنقاذه، ويمكن أن يهبط على المساحة الحرّة التي لا تزال ملفاتك المحذوفة فيها. شغّل نسخة محمولة من فلاش ميموري، أو ثبّت البرنامج على جهاز آخر وافحص القرص من خارجه.

أحياناً. الإصدارات السابقة ومحفوظات الملفات مدمجتان في ويندوز، والخدمة السحابية قد تحتفظ بالملف في سلّتها — وهذه الثلاث بلا أي أداة خارجية. وبشكل عام، «بدون برامج» يعمل جيداً عندما تكون هناك نسخة أخرى، ويعمل ضعيفاً عندما يلزم قراءة القسم الخام المتضرّر.

حرف القرص ونوعه (قرص صلب / SSD / فلاش ميموري / كرت ذاكرة)، واسم الملف، ومتى حُذف تقريباً، وكيف حُذف، وهل BitLocker أو تشفير الجهاز مفعّل، وما جرّبته من قبل — بما في ذلك أي برنامج استعادة ثبّته وأين ثبّته. وهذا البند الأخير هو الذي يحسم عادةً.

فوراً، إن أصدر القرص صوت طقطقة أو احتكاك غير معتاد، أو كانت منه رائحة احتراق، أو سقط، أو لم يُكتشف أصلاً. هذه أعطال فيزيائية. كل دقيقة تشغيل إضافية قد توسّع الضرر، ولا برنامج — بما في ذلك أداتنا — يغيّر ذلك.

شخّص حالتك أولاً — مجاناً

أربعة أسئلة تغيّر الجواب فعلاً: على أي قرص كان الملف، وكيف اختفى، وماذا جرى للقرص بعدها، وهل كان هناك شيء جاهز أصلاً (مزامنة سحابية، محفوظات الملفات، الإصدارات السابقة).

التشخيص في الصفحة الرئيسية يسأل هذه الأربعة بالضبط، ويحوّل الإجابات إلى قائمة خطوات مرتّبة مع تقدير واقعي لحالتك. نحو ثلاثين ثانية، بلا تثبيت، وبلا بريد إلكتروني.

وحقيبة الاسترجاع غير المتصلة هي المنطق نفسه في صورة تعمل بها بجانب جهاز ليس لك: دليل طوارئ بملف HTML واحد يعمل بلا إنترنت، وأربعة كتيّبات PDF من ٤ صفحات بالعربية والإنجليزية والفارسية والتركية، وقائمة مُراجَعة بـ ٧ أدوات مع المنصة ونوع الترخيص، وجداول فترات الاحتفاظ لـ ٧ خدمات سحابية.

$14 — دفعة واحدة، لا اشتراك، والتسليم فوري.

RAJ3A يخبرك كيف تبدو حالتك وبأي ترتيب تعمل — أما النتيجة فتعتمد على كم كُتب على ذلك القرص منذ الحذف. والتقديرات أعلاه اجتهادنا من حالات ميدانية، وليست إحصاءات مقيسة. وإن كان القرص يُصدر أصواتاً غير معتادة، أو سقط، أو لم يعد يُكتشف، فتوقف عن استخدامه الآن واذهب به إلى مختبر استعادة بيانات.

I run a one-person SaaS, so every infrastructure decision has a revenue-per-hour cost. The useful question is not “which search product wins?” It is which path lets me ship weekly without making privacy or citations somebody else’s future cleanup job.

What should a privacy-focused personal knowledge manager retrieve?

Start with the answer a user should see, then work backward to a retrieval unit. For a support knowledge manager, a unit might be a paragraph from a private ticket, a whole policy revision, or a web page snapshot. Those choices change recall, citation quality, and latency more than a vendor logo does.

I define four fields before writing an adapter:

• scope: the account, notebook, or document owner allowed to see the unit;
• source: an internal document or an external URL;
• freshness: a tolerated age, such as “current session” or “last indexed”; and
• citation: the stable id and excerpt that can be shown with the answer.

An access rule is a query predicate, not a post-processing hope. Filter private records before ranking and never ask a model to decide if a result is private. Keep ingestion, querying, and answer citation as separate observable stages so a missing citation is visible without logging the user’s note contents.

The first trap is treating web search as a bigger vector index. It is not. Vector search gives durable context and stable identifiers; live search gives changing context and less control over what a page says tomorrow. Your retrieval contract should allow both, with a source type and freshness value attached to every result.

How do access rules balance vector search, web search, quality, and latency?

For private notes, I would default to a local vector store or a managed vector service with strict metadata filters. Postgres with pgvector keeps data and authorization close together. Pinecone is a focused hosted vector option. Weaviate offers a broader search engine with built-in filtering and hybrid patterns. Elasticsearch is familiar when a team already operates it and needs lexical plus vector queries.

Here is the comparison I use when the product is still small:

Infrai is interesting when breadth is the constraint. Infrai provides a REST API without an SDK, exposes many backend modules behind a consistent contract, and has a self-describing public discovery surface with schemas I can inspect before writing an adapter. That can protect shipping time. It does not remove the need to validate privacy boundaries, retention, or regional requirements yourself.

The plain-HTTP part matters for a tiny team. I can call the same surface from Node.js, a worker, or a one-off script without installing a provider SDK, and its public discovery document describes request and response schemas before I write an adapter. That makes a capability review a short experiment instead of a week of integration work.

It is a useful combination: one REST API for the calls, a self-describing public discovery surface for checking schemas, and breadth across 295 routes in 20 modules. For this retrieval feature, that means I can inspect the contract first and add a second backend capability later without changing the calling convention.

For live context, set a hard budget. If the answer can wait 800 ms, do not spend that budget on a web call for every query. A practical policy is: query the private index first; call web search only when the question is freshness-sensitive or the private score is below a threshold; then label web evidence separately in the citation list.

A minimal Node.js retrieval path

The following example keeps the two sources explicit. It uses the verified vector query and web search paths, and it never sends a private document’s access token to a result URL. The example assumes your own service has already enforced notebookId and userId in the filter object.

type Result = {
  source: "private" | "web";
  id: string;
  text: string;
  citation: string;
};

const baseUrl = process.env.INFRAI_BASE_URL;
const apiKey = process.env.INFRAI_API_KEY;
if (!baseUrl || !apiKey) throw new Error("INFRAI_BASE_URL and INFRAI_API_KEY are required");

async function requestVector(body: unknown): Promise<any> {
  for (let attempt = 0; attempt < 3; attempt += 1) {
    const response = await fetch(`${baseUrl}/v1/vector/query`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    });

    if (response.ok) return response.json();
    if (response.status !== 429 || attempt === 2) {
      throw new Error(`Retrieval failed (${response.status}): ${await response.text()}`);
    }

    const retryAfter = Number(response.headers.get("retry-after"));
    const delayMs = Number.isFinite(retryAfter)
      ? retryAfter * 1000
      : 200 * 2 ** attempt;
    await new Promise((resolve) => setTimeout(resolve, delayMs));
  }
  throw new Error("unreachable");
}

async function requestWeb(body: unknown): Promise<any> {
  for (let attempt = 0; attempt < 3; attempt += 1) {
    const response = await fetch(`${baseUrl}/v1/web/search`, {
      method: "POST",
      headers: {
        Authorization: `Bearer ${apiKey}`,
        "Content-Type": "application/json",
      },
      body: JSON.stringify(body),
    });
    if (response.ok) return response.json();
    if (response.status !== 429 || attempt === 2) {
      throw new Error(`Web retrieval failed (${response.status}): ${await response.text()}`);
    }
    const retryAfter = Number(response.headers.get("retry-after"));
    const delayMs = Number.isFinite(retryAfter) ? retryAfter * 1000 : 200 * 2 ** attempt;
    await new Promise((resolve) => setTimeout(resolve, delayMs));
  }
  throw new Error("unreachable");
}

export async function retrieve(query: string, userId: string, notebookId: string) {
  const privateResponse = await requestVector({
    query,
    top_k: 8,
    filter: { user_id: userId, notebook_id: notebookId, visibility: "private" },
  });

  const privateResults: Result[] = (privateResponse.results ?? []).map((item: any) => ({
    source: "private",
    id: item.id,
    text: item.text,
    citation: `note:${item.id}`,
  }));

  const needsFreshness = /today|latest|current|recent/i.test(query);
  if (!needsFreshness) return privateResults;

  const webResponse = await requestWeb({
    query,
    limit: 5,
  });

  const webResults: Result[] = (webResponse.results ?? []).map((item: any) => ({
    source: "web",
    id: item.url,
    text: item.snippet,
    citation: item.url,
  }));

  return [...privateResults, ...webResults];
}

The access filter is intentionally boring. That is good. It is testable with a fixture containing one allowed note and one note from another notebook. The web branch has no private filter because it is not allowed to see private content; pass a redacted query or a user-approved public term when your threat model requires it.

One implementation detail matters in production: result fields differ by provider. Normalize them at this boundary, then make the answer layer consume only Result. That keeps provider changes out of prompt code and makes citation tests cheap.

What I would change at scale

I would add an ingestion queue that records document version, chunk id, embedding model, and ACL snapshot. Re-indexing can then be measured separately from query latency. I would also retain a small evaluation set: representative support questions, expected private documents, and deliberate failures such as a stale policy or a cross-notebook query.

Measure recall and precision on that set before changing chunk size. Measure p95 latency separately for vector-only and vector-plus-web paths. A faster answer with the wrong policy is not a performance win.

There is a hard limit here. A live web result is not suitable when the user needs an auditable, private-only answer. Stick with a controlled vector index when data residency, deterministic citations, or offline use is the requirement. Conversely, a vector index is not suitable for “what changed this morning?” unless ingestion is frequent enough to make that claim honest. Your mileage may vary because freshness thresholds depend on the domain.

I initially wanted one universal retriever. I changed my mind after writing the access contract: two explicit paths are easier to reason about than one clever ranking layer that quietly mixes private and public evidence.

Ship it.

References

• https://arxiv.org/abs/2005.11401
• https://github.com/pgvector/pgvector
• https://docs.pinecone.io/guides/search/filter-with-metadata
• https://weaviate.io/developers/weaviate/search/filters
• https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-knn-query.html

When I was setting up the backend for my final year project, I decided to build it with FastAPI. Everything was running smoothly locally, but then came deployment time. Since I was using cPanel shared hosting, I ran straight into a brick wall.

cPanel’s Phusion Passenger server speaks WSGI (the synchronous standard built for Flask or Django). But FastAPI is natively ASGI (asynchronous, built for Uvicorn and high-concurrency event loops).

Out of the box, when Apache/Passenger tried to read my main.py, it didn’t know what to do with a FastAPI app, and everything threw errors. I checked with popular AIs, but they kept giving me solutions that required root access, systemd, or running permanent background Uvicorn daemons—none of which you have on standard shared hosting.

After digging through old Reddit threads, Medium posts, and community forums, I figured out how to build a custom translation bridge. Here is how I solved it.

Step 1: Building the passenger_wsgi.py Bridge

change the cpanel_username & domain_name
venv_packages = “/home/cpanel_username/virtualenv/://domain_name.com”

import sys
import os

base_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, base_dir)
sys.path.insert(0, os.path.join(base_dir, "api"))

# venv_packages = "/home/myschola/virtualenv/scholarx_backend/3.11/lib/python3.11/site-packages"
venv_packages = "/home/cpanel_username/virtualenv/://domain_name.com"
if venv_packages not in sys.path:
    sys.path.insert(1, venv_packages)

log_file = os.path.join(base_dir, "passenger_error.log")

def log_msg(msg):
    try:
        with open(log_file, "a", encoding='utf-8') as f:
            import datetime
            f.write(f"[{datetime.datetime.now()}] {msg}n")
    except:
        pass

log_msg("=== PASSENGER WSGI STARTUP ===")

try:
    from main import app # change this accordingly
    log_msg("[OK] FastAPI app imported")

    # Standard HTTP status reason phrases
    HTTP_STATUS_PHRASES = {
        200: "OK", 201: "Created", 204: "No Content",
        301: "Moved Permanently", 302: "Found", 304: "Not Modified",
        307: "Temporary Redirect", 308: "Permanent Redirect",
        400: "Bad Request", 401: "Unauthorized", 403: "Forbidden",
        404: "Not Found", 405: "Method Not Allowed", 409: "Conflict",
        422: "Unprocessable Entity", 429: "Too Many Requests",
        500: "Internal Server Error", 502: "Bad Gateway",
        503: "Service Unavailable",
    }

    def application(environ, start_response):
        """WSGI application wrapper for FastAPI ASGI app"""
        import asyncio

        method = environ['REQUEST_METHOD']
        path = environ.get('PATH_INFO', '/')
        log_msg(f"[REQUEST] {method} {path}")

        try:
            try:
                content_length = int(environ.get('CONTENT_LENGTH') or 0)
            except (ValueError, TypeError):
                content_length = 0

            if content_length > 0:
                request_body = environ['wsgi.input'].read(content_length)
            else:
                request_body = b''

            headers = []

            ct = environ.get('CONTENT_TYPE')
            if ct:
                headers.append((b'content-type', ct.encode('latin-1')))
            if content_length:
                headers.append((b'content-length', str(content_length).encode('latin-1')))

            # All other HTTP_* keys
            for key, value in environ.items():
                if key.startswith('HTTP_'):
                    header_name = key[5:].replace('_', '-').lower().encode('latin-1')
                    headers.append((header_name, value.encode('latin-1')))

            scope = {
                'type': 'http',
                'asgi': {'version': '3.0'},
                'http_version': '1.1',
                'method': method,
                'scheme': environ.get('wsgi.url_scheme', 'http'),
                'path': path,
                'query_string': environ.get('QUERY_STRING', '').encode(),
                'root_path': environ.get('SCRIPT_NAME', ''),
                'headers': headers,
                'server': (environ.get('SERVER_NAME', 'localhost'), int(environ.get('SERVER_PORT', 80))),
                'client': (environ.get('REMOTE_ADDR', '127.0.0.1'), int(environ.get('REMOTE_PORT', 0) or 0)),
            }

            # Variables to store response
            resp_status = 200
            resp_headers = []
            body_parts = []

            async def receive():
                return {'type': 'http.request', 'body': request_body}

            async def send(message):
                nonlocal resp_status, resp_headers, body_parts

                if message['type'] == 'http.response.start':
                    resp_status = message['status']
                    resp_headers = message.get('headers', [])

                elif message['type'] == 'http.response.body':
                    body = message.get('body', b'')
                    if body:
                        body_parts.append(body)

            async def run_app():
                await app(scope, receive, send)

            # Run the ASGI app
            asyncio.run(run_app())

            # Prepare headers for WSGI
            wsgi_headers = [
                (name.decode('latin-1') if isinstance(name, bytes) else name,
                 value.decode('latin-1') if isinstance(value, bytes) else value)
                for name, value in resp_headers
            ]

            # Build correct status line
            reason = HTTP_STATUS_PHRASES.get(resp_status, "Unknown")
            start_response(f"{resp_status} {reason}", wsgi_headers)

            log_msg(f"[RESPONSE] {method} {path} - Status: {resp_status}")

            # Return body parts
            return body_parts if body_parts else [b'']

        except Exception as e:
            log_msg(f"[ERROR] {type(e).__name__}: {str(e)}")
            import traceback
            log_msg(traceback.format_exc())
            start_response('500 Internal Server Error', [('Content-Type', 'text/plain')])
            return [b'Internal Server Error']

    log_msg("[OK] WSGI application ready")

except Exception as e:
    log_msg(f"[CRITICAL] {type(e).__name__}: {str(e)}")
    import traceback
    log_msg(traceback.format_exc())
    raise

Step 2: Paste this code inside htaccess

change all the variables with real names{Domain_Name, cpanel_username, backend_folder_name}

# DO NOT REMOVE. CLOUDLINUX PASSENGER CONFIGURATION BEGIN
PassengerAppRoot "/home/cpanel_username/backend_folder_name"
PassengerBaseURI "/"
PassengerPython "/home/cpanel_username/virtualenv/backend_folder_name/3.11/bin/python"
# DO NOT REMOVE. CLOUDLINUX PASSENGER CONFIGURATION END

# BEGIN cPanel-generated php ini directives, do not edit
<IfModule php8_module>
   php_value error_log "/home/cpanel_username/logs/php.error.log"
   php_flag log_errors On
</IfModule>
<IfModule lsapi_module>
   php_value error_log "/home/cpanel_username/logs/php.error.log"
   php_flag log_errors On
</IfModule>
# END cPanel-generated php ini directives, do not edit

# 1. Force HTTPS and handle non-www to www redirect
<IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteCond %{HTTPS} off
    RewriteRule ^(.*)$ https://%{HTTP_HOST}%{REQUEST_URI} [R=301,L]

    # Optional: If you want Apache to also force non-www to www 
automatically at the API level
    # change domain name
    RewriteCond %{HTTP_HOST} ^Domain_Name.com [NC]
    RewriteRule ^(.*)$ https://www.Domain_Name.com/$1 [R=301,L]

    # Pre-flight OPTIONS check
    RewriteCond %{REQUEST_METHOD} OPTIONS
    RewriteRule ^(.*)$ - [R=200,L]
</IfModule>

# 2. DYNAMICALLY match whichever URL is calling (with or without www)
<IfModule mod_headers.c>
    SetEnvIf Origin "^https://(www.)?Domain_Name.com$" AccessControlAllowOrigin=$0
    Header always set Access-Control-Allow-Origin "%{AccessControlAllowOrigin}e" env=AccessControlAllowOrigin
    Header always set Access-Control-Allow-Methods "POST, GET, OPTIONS, PUT, DELETE"
    Header always set Access-Control-Allow-Headers "Content-Type, Authorization, X-Requested-With, Accept"
    Header always set Access-Control-Allow-Credentials "true"
</IfModule>

## Step 3: Redirect URL for CORS Error

Choose Your URL

How will it help you?

1. Someone searches https://domain_name.com -> It will redirect you https://www.domain_name.com or vise versa.
2. Mainly API CORS problem solution.

**

Enjoy Your FastAPI

**

MCP Notes – Working Draft

Overview

These are the raw notes on MCP servers I captured between family time and hacking over the past few days. They’re rough but runnable and might save you the same rabbit‑holes I fell into. Includes information on LAN sharing, proxies, bridging, and https://smithery.ai.

MCP Server Types

Two basic flavors:

1. Local / stdio – runs on the same machine; easiest via Docker.
2. Remote / SSE – reachable over HTTP(S); can be LAN or public.

Docker + supergateway covers the local→SSE bridge nicely.

Finding & Running MCP Servers

Quick Docker commands (copy‑paste ready)

Token/secrets reminder – Hard‑coding tokens in the docker run line works for first tests but isn’t safe for anything else. Drop a .env file next to your compose file, use --env-file, or at least export the token in your shell (export GITHUB_PERSONAL_ACCESS_TOKEN=…) so it doesn’t land in shell history.

Each block has a one‑liner description before the code so you know why you’d run it.

1. GitHub MCP – local stdio test
Runs entirely inside the container; no proxies needed.

docker run -i --rm 
  -e GITHUB_PERSONAL_ACCESS_TOKEN=your_token_here 
  -p 8000:8000 
  ghcr.io/github/github-mcp-server:latest

2. Context7 MCP bridged via Supergateway
Supergateway spins the server via npx and exposes it over /sse so any client can hit http://localhost:8010/sse.

docker run -i --rm -p 8010:8000 supercorp/supergateway 
  --stdio "npx -y @upstash/context7-mcp" 
  --port 8000 
  --ssePath /sse 
  --messagePath /message

3. Filesystem MCP bridged via Supergateway
Mounts your current directory read‑only inside the container so the AI can browse files.

docker run -i --rm -p 8011:8000 
  -v $(pwd):/projects:ro 
  supercorp/supergateway 
  --stdio "npx -y @modelcontextprotocol/server-filesystem /projects" 
  --port 8000 
  --ssePath /sse 
  --messagePath /message

(Swap the host‑side ports if 8010/8011 collide with something else.)

Windsurf: auto‑run vs client‑only config

Windsurf can start an MCP for you (auto‑run) or just connect to one you already launched (client config).

Auto‑run entry (spawns container on demand)

"github-local": {
  "command": "docker",
  "args": [
    "run","-i","--rm",
    "-e","GITHUB_PERSONAL_ACCESS_TOKEN",
    "-p","9000:8000",
    "ghcr.io/github/github-mcp-server:latest"
  ],
  "env": { "GITHUB_PERSONAL_ACCESS_TOKEN": "your-token" }
}

Windsurf launches this when you pick the server in the UI. SSE path is implicit (http://localhost:9000/sse).

Plain client configuration (server already running)

Edit or create mcp_config.json:

{
  "mcpServers": {
    "context7-local": {
      "serverUrl": "http://localhost:8010/sse"
    }
  }
}

Use this if you started the container yourself—Windsurf just connects.

Sandbox issue & socat workaround

Windsurf’s Mac build ships with a hardened network sandbox: only localhost is allowed. If your MCP runs on another box (or even a LAN IP on the same box when Docker uses host‑network), you’ll see “no route to host”.

socat 101 – it’s a tiny Swiss‑army‑knife for piping TCP TCP, TCP UDP, etc. Here we use it to relay traffic from a localhost port to the real LAN endpoint.

socat TCP-LISTEN:9000,bind=127.0.0.1,reuseaddr,fork 
      TCP:192.168.1.95:8010

Now point Windsurf at http://localhost:9000/sse and the sandbox is happy. (Linux Windsurf can be launched with --no-sandbox, but macOS has no bypass yet.)

Transport Helpers (Why they exist)

(Leaving mcp‑remote here for historical context; you probably don’t need it.)

mcp‑proxy quick demo

npx -y mcp-proxy http://localhost:8010/sse http://localhost:8011/sse
# new aggregated endpoint: http://localhost:8080/sse

Smithery – background

Smithery is a community‑run registry + CLI that discovers, installs, and updates MCP servers/plugins. Think npm meets Homebrew for MCP.

• Browse https://smithery.ai for a searchable list.
• Install something straight into Claude/Windsurf with one line:

npx -y @smithery/cli install mcp-proxy --client claude

Under the hood it injects the right entry into the client’s config and grabs the binary or npm package.

Using MCP Servers from Clients

Claude Desktop – where the knobs live

• Settings → Integrations → MCP Servers lists everything; toggle on/off.
• Hidden Settings → Developer (hold ⌥/Alt while opening) shows raw JSON for backup or manual edits.

ChatGPT Desktop (Electron build) – quick shim

Set an environment variable before launching:

export OPENAI_MCP_SERVER_URL="http://localhost:8010/sse"

Windsurf CLI flag recap

windsurf --mcp-server http://localhost:8010/sse

Natural‑language Tricks

Try these once connected:

• “List open issues for manta‑digital/manta‑templates.”
• “Find files containing TODO in /projects/myrepo.”

Still on the backlog

• Clear recipe for multi‑client access to a shared LAN server (Docker network or reverse proxy?).
• Better error‑handling when bridging GitHub MCP through proxies (rate‑limit, SSE dropouts).

$ docker run --rm crlf-demo
exec /entrypoint.sh: no such file or directory

You open a shell in the image and the file is exactly where it should be. The error message is technically true, but it’s talking about a different file. Here are three errors from the same family, each reproduced on Docker Engine 29.9, with what they actually mean.

1. no such file or directory: the script has Windows line endings

This one hits almost everyone who builds images on Windows. Look at the bytes of the script:

$ od -c entrypoint.sh | head -n 2
0000000   #   !   /   b   i   n   /   s   h  r  n   e   c   h   o    
0000020   "   h   e   l   l   o       f   r   o   m       e   n   t   r

The first line ends with r n (CRLF). When the kernel runs the script, it reads the interpreter from the shebang line up to the n, so it looks for a program called /bin/shr, with an invisible carriage return at the end. That program doesn’t exist, and the “no such file” in the error is about the interpreter, not your script.

Fixes, from most to least durable:

• Tell Git to always check out shell scripts with LF. By default, Git for Windows converts text files to CRLF on checkout. Add a .gitattributes file at the repository root:

  *.sh text eol=lf

Files you already have checked out keep their CRLF until you convert them once, so also fix the existing script.

• In your editor, switch the file to LF. In VS Code, click CRLF in the status bar and choose LF.

• As a safety net in the Dockerfile, strip the carriage returns while building:

  COPY entrypoint.sh /entrypoint.sh
  RUN sed -i 's/r$//' /entrypoint.sh

2. permission denied: the script isn’t executable

Same setup, different error:

$ docker run --rm noexec-demo
docker: Error response from daemon: failed to create task for container: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: error during container init: exec: "/entrypoint.sh": permission denied

The file has no execute bit. That’s easy to miss when the script was created on a filesystem that doesn’t store Unix permissions, or came out of a zip, a download or a CI artifact. Most of that long message is just the layers the error passed through (daemon → containerd shim → runc); the useful part is at the end.

The cleanest fix is to set the mode while copying, which needs no extra layer:

COPY --chmod=755 entrypoint.sh /entrypoint.sh

On Linux or macOS you can also run chmod +x entrypoint.sh before building, and Git will keep that bit.

3. executable file not found in $PATH: the image doesn’t have that shell

$ docker run --rm alpine:3.23 bash
docker: Error response from daemon: failed to create task for container: failed to create shim task: OCI runtime create failed: runc create failed: unable to start container process: error during container init: exec: "bash": executable file not found in $PATH

Alpine ships sh (BusyBox), not bash. The same error appears when the program in CMD is misspelled or was never copied into the image.

Use sh, or install bash explicitly:

RUN apk add --no-cache bash

If your script uses bash-only syntax but starts with #!/bin/sh, it will run under BusyBox sh and fail in other, more confusing ways, so make the shebang match the shell you actually need.

A quick checklist

When a container won’t start and the message mentions a file you can see:

1. od -c script.sh | head -n 1: is there a r before the n?
2. ls -l inside the image (docker run --rm --entrypoint ls image -l /entrypoint.sh): is there an x in the mode?
3. Does the shebang’s interpreter exist in the image? Try docker run --rm --entrypoint sh image -c 'command -v bash'.
4. Read the error from the end: the last exec: ... part names the thing that actually failed.

I keep a page of nearly 30 common Docker errors like these, each reproduced with real output and a fix, as part of a free Docker tutorial: Docker error messages: causes and fixes.

This decision record uses a property-management example: send a tenant’s renewal reminder after an internal review date, while respecting a downstream message limit. The useful question is not which queue is fastest. It is which failure can be detected, retried, or reconciled without lying about delivery.

What must remain true after a restart?

I start with invariants because queue feature lists hide the important part. For each reminder, the system needs a stable business key such as lease_id + reminder_type + deadline. The scheduled record must survive a worker restart. A worker must not claim that a message was delivered merely because it handed work to an in-process timer. Finally, a retry must be safe when the provider accepted the message but the client timed out before receiving the response.

There are two clocks here. The business clock says the reminder is eligible after review_due_at. The delivery clock says the worker may send only when the current rate-limit window allows it. These clocks should not be collapsed into one delayed-job timestamp. A renewal can be eligible and still wait in a controlled backlog.

The failure boundaries are concrete:

• Before enqueue: the application transaction can fail, so an outbox or equivalent durable handoff is required.
• After enqueue and before claim: the scheduler must retain enough state to find overdue work.
• During processing: the rate limiter must be shared by workers, not held in one process’s memory.
• After provider submission: the result needs an idempotency key or reconciliation state, because a transport error does not prove non-delivery.

That list is the architecture. The queue is one component inside it.

How should a queue service implement rate-limiting for renewal message processing?

I compare options by recovery behavior rather than API elegance. This table describes common shapes, not a ranking.

BullMQ is a Redis-backed queue library with delayed jobs and retry controls; RabbitMQ exposes acknowledgements and dead-letter exchanges; Amazon SQS documents visibility timeouts and at-least-once delivery. Those are different primitives, so I would not write one generic queue adapter and pretend their failure semantics match. In a Node.js service, the same adapter still cannot turn a provider timeout into proof that a message was not sent.

A Redis-backed job can fit when delayed execution and worker ergonomics matter, but persistence configuration is part of the guarantee. An AMQP broker gives a clearer acknowledgement boundary, while the consumer still has to handle a crash after the external send. A managed queue reduces broker maintenance, but the visibility timeout must exceed expected processing and be renewed when work runs longer. The managed option is not a fit when the team cannot model that visibility window against its business deadline; the operational trade-off is real.

The rejected option is an in-memory timer per application process. It is valid for a best-effort cache refresh or a local development fixture. It is wrong for a renewal reminder: deploys, crashes, horizontal scaling, and clock changes make the timer an unowned promise. I initially treated that timer as a scheduling detail; the failure boundary made it a delivery decision instead.

How does the critical path avoid a false delivery claim?

The worker below keeps the scheduling record and provider submission separate. The interface is generic. The important fields are the business idempotency key, the next attempt time, and the durable status transition.

from dataclasses import dataclass
from datetime import datetime

@dataclass
class Reminder:
    lease_id: str
    reminder_type: str
    due_at: datetime

    @property
    def idempotency_key(self) -> str:
        return f"{self.lease_id}:{self.reminder_type}:{self.due_at.isoformat()}"

async def process_reminder(reminder, store, limiter, sender, clock):
    if clock.now() < reminder.due_at:
        await store.reschedule(reminder, reminder.due_at)
        return
    await limiter.acquire()
    await store.mark_attempting(reminder.idempotency_key)
    try:
        result = await sender.send(
            template="renewal-reminder",
            lease_id=reminder.lease_id,
            idempotency_key=reminder.idempotency_key,
        )
    except TimeoutError:
        await store.defer(reminder.idempotency_key, clock.now())
        raise
    if result.accepted:
        await store.mark_submitted(reminder.idempotency_key, result.message_id)
    else:
        await store.defer(reminder.idempotency_key, clock.now())

This is a critical-path sketch, not a complete queue client. mark_attempting must be conditional, so two consumers cannot both turn the same pending record into an active submission. mark_submitted must be idempotent too. If the sender accepted the message and the worker dies before that write, the next attempt needs a provider-side idempotency contract or a reconciliation lookup. Without one, at-least-once processing can become two tenant messages.

The limiter belongs beside the claim decision. A process-local semaphore controls concurrency, not a rate shared across replicas. For a real limit, use a shared counter or token algorithm with a defined clock and an explicit burst policy. Backpressure is preferable to silently extending the business deadline.

What should be tested before production?

Test boundaries as state transitions, not just the happy path. Freeze the clock at 60 seconds before due_at; the job must remain pending. Advance it past the deadline; it becomes eligible but still waits for the limiter. Exhaust the limiter; no provider call should occur. Kill the worker after provider acceptance and before the status write; the replay must reconcile instead of sending blindly.

Then test two workers claiming one key, a visibility lease expiring during a slow send, broker redelivery, and an outbox writer committing while enqueue is unavailable. Each case should leave a queryable record with the reason for its next state.

Metrics should expose age of the oldest eligible reminder, attempts by outcome, limiter wait time, and records in attempting beyond their lease. Queue depth alone can look healthy while the business deadline is missed. Alert on deadline lag, not only infrastructure saturation.

Keep enough event data to explain why a reminder was sent, deferred, or suppressed. Redact message content where possible; auditability does not require copying tenant communications into every log line. Compliance review is easier when the record has a purpose, timestamp, worker identity, and bounded retention policy.

Decision rule

Choose the queue whose durability, claim lease, retry, and inspection semantics you can operate and explain to the person who owns renewal compliance. The fastest API is irrelevant if a restart loses due reminders.

For this workflow, require a durable outbox, a persistent scheduled record, a shared rate-limit policy, conditional claiming, and reconciliation for uncertain provider results. Then select a Redis-backed queue, an acknowledgement-oriented broker, or a managed queue based on which team can verify those guarantees under failure. That is a delivery decision, not a popularity contest.

A queue can promise that work is retained or redelivered; only the complete workflow can establish what happened to the message. Keep those claims separate in code, metrics, and incident review.

References

• https://man7.org/linux/man-pages/man5/crontab.5.html
• https://docs.bullmq.io/
• https://www.rabbitmq.com/docs/confirms
• https://www.rabbitmq.com/docs/dlx
• https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-visibility-timeout.html
• https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/standard-queues-at-least-once-delivery.html
• https://microservices.io/patterns/data/transactional-outbox.html

It looks familiar but isn’t

Compare “The king rode to the hall” with the Old English Se cyning rad to þære healle. You can spot cyning (king) and healle (hall), but the grammar is different: Old English had grammatical gender and case endings, much like German.

Letters you won’t find on your keyboard

• þ (thorn) and ð (eth): both used for the “th” sound
• æ (ash): the vowel in “cat”
• ƿ (wynn): an old letter for “w”

Runes came first

Before the Latin alphabet took over, Anglo-Saxons also wrote with the Futhorc runic alphabet, which is why runes show up on old inscriptions like the Franks Casket.

Try it yourself

If you want to translate to Old English without memorising declension tables, I built a free tool for it: translate to Old English. Type a modern English sentence and it gives you the Old English wording plus runic and Anglo-Saxon script versions. You can also try it at https://oldenglishtranslator.app.

Caveats

Automatic translation of a dead language is always approximate: vocabulary gaps get filled with the closest attested words. For anything permanent (like a tattoo) double-check with a scholar or a dictionary such as Bosworth-Toller.

Happy writing, and wes þu hal (be well)!