DEV Community: Jonathan Bajrami

DETACHED_PROCESS made my background jobs open more windows, not fewer

Jonathan Bajrami — Mon, 26 Oct 2026 00:34:05 +0000

A good share of my automation runs on a Windows desktop, not a server. Some jobs need things only that machine has: a signed-in browser, local credentials, a checkout of the repo. The rest run on a small Linux server under systemd. Windows Task Scheduler starts the desktop ones, some as often as every ten minutes.

Two problems kept coming back. Terminal windows popped up over whatever I was doing. And when a job stopped running, nothing told me. This is how each one broke and what fixed it.

Window one: the task itself

The first case was simple. A sync job ran every ten minutes, and its scheduled task pointed at cmd.exe running a .bat file. Every ten minutes a console window opened, ran for a few seconds and closed, usually while I was typing.

The usual advice is powershell.exe -WindowStyle Hidden. In my experience it still flashes. PowerShell is a console program, so Windows gives it a console window before PowerShell has a chance to read its own arguments and hide it.

What worked was launching through wscript.exe, which is a GUI program and gets no console, and having a tiny VBScript start the real command with window style 0:

' run-hidden.vbs: wscript.exe run-hidden.vbs "C:\path\to\job.bat"
Set args = WScript.Arguments
If args.Count = 0 Then WScript.Quit 2

cmd = ""
For i = 0 To args.Count - 1
    a = args(i)
    If InStr(a, " ") > 0 Or a = "" Then a = """" & a & """"
    cmd = cmd & a & " "
Next
cmd = Trim(cmd)

ext = LCase(Right(args(0), 4))
If ext = ".bat" Or ext = ".cmd" Then cmd = "cmd.exe /c """ & cmd & """"

WScript.Quit CreateObject("WScript.Shell").Run(cmd, 0, True)

The last argument, True, matters more than it looks. It makes the script wait for the job to finish. That keeps the task in the Running state for the whole job, which lets the "do not start a new instance" setting skip an overlapping run, and it passes the job's exit code back as the task's last result. Without the wait, every run reports success in a fraction of a second, whatever the job did.

The scheduled action looks like this:

$a = New-ScheduledTaskAction -Execute 'wscript.exe' `
  -Argument '"C:\path\to\run-hidden.vbs" "C:\path\to\job.bat"'

For a Python entry point with no child processes, pythonw.exe does the same job directly. I moved every task over and the windows stopped. For a while.

Window two: the grandchildren

A few weeks later they were back, from jobs that were already launching through the hidden wrapper.

These jobs start other processes. One monitor, when it raises an alert, starts a background worker that launches a headless coding-agent run to investigate. Two others start headless agent runs of their own. A notification job running under pythonw calls git, ssh and powershell. The parent was hidden. Its children were not.

The worker launch looked like this:

flags = (subprocess.CREATE_NO_WINDOW | subprocess.DETACHED_PROCESS) if os.name == "nt" else 0
popen([sys.executable, "-m", "worker", "run", run_id], creationflags=flags, ...)

Both flags sound like "no window". Together they gave me windows.

Why does that combination open windows?

Microsoft's process creation flags page answers it in one line. CREATE_NO_WINDOW "is ignored if the application is not a console application, or if it is used with either CREATE_NEW_CONSOLE or DETACHED_PROCESS."

So the effective flag was DETACHED_PROCESS alone, and a detached process has no console at all. That's fine for the Python worker, which prints nothing anyone sees. The trouble starts when it launches a console program. Per the console creation docs, a console process normally inherits its parent's console. A parent with no console has nothing to hand down, so Windows creates a new one, with a visible window. The agent CLI is a .cmd shim, which means cmd.exe, which means a console, which means a window, once per run.

pythonw has the same shape. It's a GUI-subsystem build of Python with no console, so every git or ssh it starts without flags gets a fresh console window.

The fix is to drop DETACHED_PROCESS and keep CREATE_NO_WINDOW alone:

# A hidden console, not DETACHED_PROCESS: a detached child has none,
# so the agent CLI it starts opened a terminal.
flags = subprocess.CREATE_NO_WINDOW if os.name == "nt" else 0

CREATE_NO_WINDOW gives the child a console that exists but has no window. Its own children inherit that hidden console instead of making new ones. The same flag goes on every subprocess.run and Popen in any job that runs without a console, including one-off calls to git. The rule I ended up writing down: any code that starts a process from a scheduled job passes CREATE_NO_WINDOW, and never DETACHED_PROCESS.

When a window does appear, I check two things in order. First, the non-Microsoft scheduled tasks, for any action that points straight at a console program:

Get-ScheduledTask | Where-Object TaskPath -notlike '\Microsoft\*'

Then the code those tasks run, searching for DETACHED_PROCESS and for subprocess calls with no creationflags at all.

The opposite problem: a job that stops without a sound

Hidden jobs have a downside. When one stops, you don't see that either. A desktop goes to sleep, a task gets disabled while testing, a timer on the server disappears after a reinstall. None of those produce an error, because nothing ran.

The first layer is a heartbeat wrapper around the job command, using healthchecks.io's ping API. It pings /start, runs the job, then pings the exit code. The service raises an alert when a ping is late or reports a non-zero exit.

def run(argv, send=_send, key=None, runner=subprocess.call) -> int:
    slug, cmd = argv[0], argv[2:]
    key = key if key is not None else ping_key()
    if key:
        ping(key, slug, "start", send)
    code = runner(cmd)
    if key:
        ping(key, slug, str(code if 0 <= code <= 255 else 1), send)
    return code

Three choices in there are deliberate. A failed ping (5-second timeout) is logged and swallowed, so a monitoring hiccup can never fail the job. With no key configured, the wrapper runs the job unchanged, so a job can be wired in before the monitoring account exists. And it only ever sends start and exit-code pings, never the job's output, which can contain personal data.

Is it late, or is the PC just off?

The second layer is one table of every scheduled job and always-on service on both machines, refreshed hourly. On the desktop it reads Task Scheduler through its COM interface from PowerShell. On the server it runs systemctl show over SSH. Each job gets a status: ok, running, failed, stopped (enabled but no next run), late, down (a service that should always run), missing (listed in config, gone from the machine) or off.

Task Scheduler reports results as codes, and three non-zero ones are not failures:

RUNNING_CODE = 0x41301      # the task is running now
NOT_RUN_CODES = (0x41303,)  # has not run yet
OK_CODES = (0, 0x41306)     # done; or stopped by the owner

It also reports "never" as a date in 1899 or 1999, so any date before 2001 is treated as no date.

"Late" was the hard one. A job is late when its last run is older than twice its normal gap plus a grace period. On the server the grace is 30 minutes. On the desktop it's 14 hours, because that machine is only on from about midday to one in the morning. Without that, every daily job would be flagged late every morning, and an alert that fires every morning is one I'd learn to ignore.

Two smaller details made it trustworthy. A job only counts as missing when the machine it lives on was actually reachable. If SSH to the server fails, that's one error row, not every server job marked missing at once. And a job that's on the machine but not in the config still shows up under its raw name, so a new job can't hide by being forgotten.

Alert once, and again only when something changes

Problems go to my phone, and the rule is once per problem. A small state file maps each job to the problem status already sent:

def new_problems(rows, alerted):
    fresh, keep = [], {}
    for r in rows:
        if r["Status"] in PROBLEMS:
            keep[r["Key"]] = r["Status"]
            if alerted.get(r["Key"]) != r["Status"]:
                fresh.append(r)
    return fresh, keep

A job that's still failing an hour later stays quiet. A job that moves from late to failed alerts again, because that's new information. A job that recovers drops out of the map, so if it breaks again next week, that's a fresh alert. If the phone message itself fails to send, those jobs are left out of the saved state and the next hourly run tries again.

The collector follows the window rule too: its PowerShell call passes CREATE_NO_WINDOW.

What I'd do from day one

Launch every scheduled task through a GUI host (wscript.exe with a hidden-window script, or pythonw.exe). Never point a task straight at cmd.exe, a .bat or powershell.exe.
Pass CREATE_NO_WINDOW on every child process a background job starts, and never combine it with DETACHED_PROCESS. Windows ignores it when you do.
Make the wrapper wait for the job, so the task's state and exit code mean something.
Watch for silence as well as errors, with a grace period that matches when the machine is actually on.
Alert on change, not on state.

One of the jobs that table watches is the publishing pipeline in this write-up of an automated SEO system. It runs unattended, so it's exactly the kind of job that could stop for a week with nobody noticing, without the table.

This article was drafted with AI assistance, working from the project's own scripts, commit history and Microsoft's documentation.

My website audit crawler named Google as the company that built the site

Jonathan Bajrami — Mon, 26 Oct 2026 00:33:13 +0000

I build a tool that reads a business's website before I talk to the owner. It crawls up to 60 pages, works out what the site runs on (booking system, chat widget, analytics, form handler, cookie banner) and writes one internal markdown brief for whoever makes the call. Nobody outside sees it.

One field in that brief is "who built this site". When the first build went through review, a page carrying a standard reCAPTCHA badge got this answer: policies.google.com.

Google does not build small-business websites. This post is about how that happened, the second bug the same review found, and the rule I now apply to anything that reads a website and makes a claim about it.

How a reCAPTCHA badge became a web agency

Plenty of small-business sites carry a credit in the footer from the agency that built them. The giveaway is often not the "Website by X" text. It's the legal links. An agency that hosts its clients' privacy and terms pages on its own domain leaves footer links like agency.example/privacy-policy/ and agency.example/website-terms/ on every page.

So the first version of the detector did this: for every link on every page, if it points off-site and the path contains privacy, terms or cookies, count that host as a candidate builder. Most frequent host wins.

Now look at what a standard reCAPTCHA badge puts on a page: policies.google.com/privacy and policies.google.com/terms. Off-site, on every page with a form, both paths matching. My heuristic was built to find exactly that shape. The saved site I use as the main test fixture, a real dental practice, loads assets from www.google.com too, so this was not a contrived case.

The fix had two parts. First, a short list of known infrastructure hosts that can never be the builder:

_AGENCY_INFRASTRUCTURE_HOSTS = frozenset({
    "policies.google.com", "www.google.com", "google.com",
    "support.google.com", "myaccount.google.com", "accounts.google.com",
})

Second, any host that is already a named vendor in one of the other categories (a cookie-consent provider's own policy page, say) is skipped too. When nothing is left, the field says not detected. A reCAPTCHA-only site now returns not detected, and a real agency footer still resolves.

What bothered me was where the wrong answer would end up. The brief is read by a person about to ring a real business, and "your site was built by Google" is a false statement about that business.

The bug that every test agreed with

The same review found a second problem, worse because the test suite was green.

For each detected vendor the brief reports how many pages it appeared on: len(pages) against total_pages. The reviewer tried replacing len(pages) with total_pages, which turns "1 of 8" into "8 of 8" for every vendor. The suite stayed at 115 passed.

The only test checking the page count used a review widget that appeared on 8 of 8 pages. In that case the right number and the wrong number are the same number, so the test could never tell them apart.

I now think of this as the main way a test suite lies: an oracle where the correct value and a plausible wrong value coincide. The fix was a small corpus where a vendor appears on exactly 1 of 3 pages, and a test asserting pages=1, total_pages=3. Put the mutation back and it fails.

The rule: trust where an asset came from, never what the page says

Both bugs led back to a rule that was already in the spec for vendor detection, and that I now apply to everything the tool claims.

A vendor counts as present only when a host served something to the page. The evidence is the set of external hosts in src and href attributes (scripts, iframes, stylesheets, images) and the hosts that forms post to. The detector never reads the rendered body text.

def _match_vendor(host: str, table: dict) -> Optional[str]:
    host = host.lower()
    if host in table:
        return table[host]
    for known_host, vendor in table.items():
        if host.endswith("." + known_host):  # booking.vendor.example matches vendor.example
            return vendor
    return None

Two cases in the test fixtures show why the body text is off limits.

Across the dental practice's pages, the word "dentally" appears six times, every one of them in the phrase "dentally phobic patients". Dentally is also the name of a dental booking system. A substring match over the page text reports that the practice books through Dentally. It doesn't.

On the same site, the word "crisp" appears, but only inside a WordPress CSS custom property, --wp--preset--shadow--crisp. Crisp is also a live-chat product. A text matcher reports a chat widget that isn't there.

Both are kept as negative tests. Plant a body-text matcher and they go red.

The other half of the rule is the vocabulary. When no host evidence turns up, the brief says not detected, never absent. A booking system can sit behind a button the crawler never clicked, or be wired up server-side. "We didn't see one" is a fact. "They don't have one" is a guess, and it becomes a question for the call instead.

Keeping the model away from the page text

The brief also has a judgement layer. Three model-based reviewers each look at one area: whether the site gets found and turns visits into enquiries, how enquiries are followed up, and what software the business runs on. They write prose; code checks it.

The obvious design gives each reviewer the crawl, which would undo the rule above. A model handed the dental site's HTML sees "dentally" six times and is likely to conclude the practice uses Dentally. Origin-based detection only helps if nothing downstream re-reads the text.

So the reviewers never see the crawl. The engine dumps its evidence once, then cuts a projection per reviewer: worked-out findings (vendors with their hosts, structured-data findings, which sector workflows had evidence) plus page metadata such as titles, headings and schema types. No page body, not even truncated. In the sample dump the raw pages were 127KB of a 174KB file, all of it material the rule forbids.

Page metadata is still text the business wrote, and "dentally phobic" can turn up in a meta description. So each projection also carries a contract block saying vendor claims come from the stack findings only. The projection removes most of the risk. The contract covers the rest.

Two more limits are computed in code and travel inside the projection, so a reviewer can't widen them:

The follow-up reviewer is forbidden a verdict. A website can show there are three ways to get in touch and no booking widget. It cannot show who answers the phone at 6pm.
The website reviewer loses its verdict when the crawl fetched less than 60% of the URLs it discovered. Judging a whole site from a fifth of it is the same mistake as judging something invisible.

The gate writes the file, not the person running it

The last guard is a gate script that runs over the composed brief before it is saved. One check is a deliberately blunt regular expression:

G7_PATTERN = re.compile(r"/10\b|/100\b|[0-9]/5\b|losing £|lost revenue")

It exists because this tool replaced an older audit that produced scores. That version scored eleven areas, but six couldn't be measured from free public data, so its headline number was an average over only the areas it could score. The new brief has no score, no grade and no money estimate, and this pattern keeps them out. It over-catches on purpose (a URL path like /100-club/ trips it), because clearing a false positive takes a minute and a scored brief that ships costs the call.

The other change is who writes the file. Originally the gate printed pass or fail and the person running it copied the draft across, so a failing draft could land because nobody checked an exit code. Now the gate takes --write-to and does the write itself. On failure it writes nothing and leaves the previous brief untouched.

A smaller one: the crawler refuses to audit itself

The older audit once reported that a live business had no HTTPS. It had been pointed at a local copy of the site.

The new runner refuses loopback addresses and exits with code 2. The first version compared hostnames as strings, which misses most of the ways to write "this machine". The current check normalises first, then parses with both ipaddress and socket.inet_aton, which accepts the short, decimal and hex IPv4 forms a browser accepts:

try:
    ip = ipaddress.ip_address(h)
except ValueError:
    try:
        # 127.1, 2130706433 and 0x7f000001 all parse here
        ip = ipaddress.ip_address(socket.inet_ntoa(socket.inet_aton(h)))
    except OSError:
        return False
if isinstance(ip, ipaddress.IPv6Address) and ip.ipv4_mapped is not None:
    ip = ip.ipv4_mapped
return bool(ip.is_loopback or ip.is_unspecified)

[::1], [::ffff:127.0.0.1], 0.0.0.0 and a trailing-dot 127.0.0.1. are refused; a real domain like localhost-dental.co.uk is not. There's no DNS lookup, on purpose: the offline modes must make no network calls, and a lookup during argument parsing would be one.

What I'd tell anyone writing a site analyser

Decide what counts as evidence before you write a detector. "A host served an asset" is evidence. "The page mentions a word" is not.
Write the negative fixtures early, from real pages that contain the vendor's name without using the vendor.
Plant the wrong answer and watch for red. If the suite stays green, the test is checking a case where right and wrong coincide.

The brief is an internal document that prepares a first conversation with a business, the kind of discovery work described on our AI consultancy page, and its unanswered questions are asked there rather than guessed at. Every one of the fixes above came from asking what that brief might say about a real business that wasn't true.

This article was drafted with AI assistance, working from the project's own code, commit history and test fixtures.

I banned arithmetic in my invoicing app and enforced it with an AST test

Jonathan Bajrami — Mon, 26 Oct 2026 00:26:46 +0000

The quoting and invoicing app I built has a rule that looks odd at first: the app package is not allowed to do arithmetic. No +, no -, no *, no /, no float, and no Decimal(...) outside a short list of named files.

Every money figure comes from a separate engine, quote_to_cash: one function prices a set of lines (compute_totals), a few more work out what's paid and outstanding. The app above it, a Next.js front end over a thin FastAPI layer with a SQLite file per tenant, can store figures, show them and send them on. It can't make new ones.

The reason is practical. A quote total that the API worked out one way and the PDF another is a bug a customer finds before I do. If only one module can produce a figure, the two can't disagree. And a rule like that doesn't survive long in a README, so it lives in a test.

How do you test that code doesn't do maths?

You read the code as data. Python ships its own parser, so the test walks the syntax tree of every .py file under the package and fails on anything that looks like arithmetic:

_ARITH_OPS = (ast.Add, ast.Sub, ast.Mult, ast.Div, ast.FloorDiv, ast.Mod, ast.Pow)

for node in ast.walk(tree):
    if isinstance(node, (ast.BinOp, ast.AugAssign)):
        if isinstance(node.op, _ARITH_OPS) and not exempt(path, node):
            violations.append(f"{path}:{node.lineno}: arithmetic operator "
                              f"{type(node.op).__name__} not allowed here")

On top of operators it reports any float literal, any float(...) call, any .quantize(...) call, any sum(...) outside the one aggregates module, and any Decimal(...) outside money_io.py, the boundary where a request string becomes money and money becomes a response string.

It also refuses to pass if it scanned fewer than ten files, because a gate pointed at an empty directory passes forever.

One consequence is easy to miss. pathlib overloads / for joining paths, and in the syntax tree base / "data" is a BinOp with ast.Div, the same node as a / b. The checker doesn't try to tell them apart. Instead the spec says paths are joined with Path.joinpath(), never /. It reads oddly, and it's the cheapest fix available.

The exceptions are by path, and narrow

Some files genuinely need an operator: date ageing subtracts dates, invoice numbering increments a sequence, the demo data offsets dates from today. Each gets exactly one operator, in exactly one file. Later work added a few more, and the interesting ones are narrower than "this file may use +":

The files that keep integer counters (push attempts, failed sign-ins) may use + only in the shape <expr> + 1. The check looks at the right operand and requires the literal integer 1. It also rejects True, because bool is a subclass of int in Python and n + True would otherwise pass.
The approvals store may use + only as <anything> + timedelta(...), for a 30-minute expiry. A static check can't know a name holds a datetime, so it pins the half it can see: the right operand must be a literal timedelta(...) call. now + LIFETIME is refused even though it's correct, so the code says now + timedelta(minutes=LIFETIME_MINUTES).

Each narrowing has a planted-violation test. n + 2, 1 + n and a + b in a counter file must all be reported, and n + 1 in a file with no exemption must be reported too.

What the first version let through

The first version of the gate went through a cold-read review, which found three holes.

Spellings. Version one looked for a bare name Decimal being called. These all construct a Decimal and all passed:

import decimal
from decimal import Decimal as D

decimal.Decimal("5")
D("5")
Decimal.from_float(x)
builtins.float("1")

The fix collects every alias bound by from decimal import Decimal as X in the file, and treats any call ending in .Decimal, .from_float or .float as a construction, whatever comes before the dot. A test plants all four and asserts exactly four violations.

Basenames. Exemptions were matched on the file name alone. money_io.py may construct Decimal, so a future api/money_io.py would have inherited that right just by sharing a name. Root-level exemptions now require path.parent == package_root, and nested ones are keyed by the path relative to the package root. The test builds a fake package with the same file at both levels and checks only one is exempt.

Unchecked calls inside the exempt file. The aggregates module is allowed sum, but only as sum(values, Decimal("0.00")). Version one never looked at the arguments, so sum([a, b]) with an integer start passed. It now requires exactly two positional arguments, the second being that literal.

The common thread: the gate was checking one spelling of the rule rather than the rule.

The one file that's allowed to divide

Then I added staged invoicing: bill 60% of a quote now and the rest on completion. That needs a percentage of a figure, which is multiplication and division. It went into one new file, staged/split.py, with its own short list of operators and three allowed literals: Decimal("0.01"), Decimal("0.00") and Decimal("100").

The rule in that file is that the stage that closes a quote is a remainder, never a fresh percentage. Here's the demo quote from the spec:

	Labour	Materials	Net	VAT 20%	Gross
Whole quote	338.00	272.00	610.00	122.00	732.00
60% stage	202.80	163.20	366.00	73.20	439.20
Closing stage (remainder)	135.20	108.80	244.00	48.80	292.80

338.00 - 202.80 = 135.20. Taking 338.00 × 40 / 100 gives the same 135.20 here, which is exactly the problem. The fixed oracles in the spec couldn't distinguish the two rules, because for these figures no whole-number percentage does.

Try a split that doesn't divide cleanly: 33.33%, 33.33%, 33.34%. Price the third stage as a fresh 33.34% and the three nets come to 610.01. A penny more than the quote.

Why the remainder still came out a penny short

The first implementation took the remainder on the line amounts only, then priced each stage as an ordinary invoice. The nets summed to 610.00. VAT didn't.

The engine rounds VAT once per invoice: it rounds the net, then rounds net × 20 / 100 half-up. Each of the first two stages has a net of 203.32 and VAT of 40.664, rounded to 40.66. The closing stage's lines come to 203.36, VAT 40.672, rounded to 40.67. Total VAT: 121.99 against the quote's 122.00. Gross: 731.99 against 732.00.

With two stages this never shows up. Whatever the first stage's rounding drops, the second stage's rounding picks back up. Every oracle in the spec had two stages. The review that caught it tried three.

The fix takes the remainder of every figure on the closing stage, not just the lines:

def _closing_totals(whole: Totals, earlier: Sequence[Totals]) -> Totals:
    return Totals(
        net_gbp=split.remainder(whole.net_gbp, [t.net_gbp for t in earlier]),
        vat_gbp=split.remainder(whole.vat_gbp, [t.vat_gbp for t in earlier]),
        gross_gbp=split.remainder(whole.gross_gbp, [t.gross_gbp for t in earlier]),
        # ...CIS deduction, retention and payable the same way
    )

The closing stage now carries VAT of 40.68 (122.00 - 40.66 - 40.66), a penny off what quantize(203.36 × 0.20) gives on its own. That penny is the one the earlier stages rounded away, and the last invoice is where it belongs, as a contractor's final invoice balances the account. Gross is still net plus VAT, because a difference of differences is the difference of the sums. And the subtraction goes through split.remainder, so the gate needed no new exemption.

The proof is a test that runs 7 percentage sets across 3 quotes, including a reverse-charge quote with a CIS deduction, checks all six figures against the quote's own, and goes red against a planted mutation that re-prices the closing stage from its lines.

The same review found a race

One more defect from that review, the kind a demo never shows. Two stage requests arriving together were both admitted. Both read "60% remaining", both wrote, one record overwrote the other, and 120% of the quote was pushed to the accounting system while 40% was still marked as invoiceable.

The fix is a per-quote lock held across check, write and push, plus a create-only write that raises if the record already exists. The test races two threads through two API clients with a gate clock that holds both inside the check-then-write window.

That lock is in-process only, and the commit says so. The storage layer has no transactions or compare-and-set, so two API processes against one tenant file could still race. The app runs a single local API process, so the lock covers what exists today; anything more belongs in the storage layer.

Would I do it again?

Yes. The gate is about 580 lines including its own tests. What it buys is less "no arithmetic" than "every exception is a reviewed line in one file, with a test proving it can't spread". When staged invoicing needed to divide, the change was one new path and three literals, not a search for stray multiplications.

If you want the same thing:

Put every money calculation behind one module, and make the rest of the code unable to do maths by test, not by convention.
Make the checker catch constructions, not names: decimal.Decimal, aliases, from_float, builtins.float.
Match exemptions by full path.
For splits, close with a remainder of every figure, and test with at least three parts. Two parts hide the rounding.

The user's side of this app, rather than its internals, is described on the quoting automation page: quotes priced on the business's own rate card and checked by a person before they go out.

This article was drafted with AI assistance, working from the project's own code, specs, tests and commit history.