Safety, reliability & recovery
Picketdesk is built around one promise: it can never lose a file or an icon. Here is the machinery that keeps it — and, if something ever looks wrong, exactly which lever to pull.
The three safety nets
A picket's files are hidden from Explorer while Picketdesk draws them. Three independent mechanisms make sure they always come back:
- Clean exit. Quitting Picketdesk un-hides every file it hid and leaves a receipt on the desktop that lists them. Once that restore has started, nothing in the app hides a file again before it exits, so your files cannot vanish a second time on the way out.
- The watchdog sibling. A separate process watches the
app; if Picketdesk is killed hard, the watchdog restores the icons
automatically. It is started so that it is not part of Picketdesk's
process tree, so ending Picketdesk's whole tree does not end the
watchdog with it. It is itself watched: Picketdesk checks every 30 seconds
that the sibling is still the process it started, and re-arms a new
one if it was killed — so the net cannot quietly go down and leave
you unprotected without anyone noticing. Only a run of quick losses
stops it: if three new siblings in a row are gone again within ten
minutes (a start that antivirus blocks or kills at once), Picketdesk
stops trying, writes so in
picket.log, and Settings → Safety shows the net as down. It then tries once an hour, so a block that lifts later does not leave the rest of the session without a net. A sibling that stayed up longer is always replaced. It does not depend on the ledger file either: ifworkspace.jsonis locked when the app dies it waits a few seconds, if it is unreadable or corrupt it walks the rotated backup instead, and in every case it also sweeps the desktop for files carrying Picketdesk's claim marker — the same evidence the launch sweep spends. - The manual rescue. Start menu →
Picketdesk - Restore desktop files (quits Picketdesk):
un-hides every file Picketdesk hid, then tells you in a window what it
restored and anything it could not. It is
picket-app.exe --restore-iconsunderneath — the installer adds no command to your PATH, so typed by hand it needs the full path,"%LOCALAPPDATA%\Picketdesk\picket-app.exe" --restore-iconsfor the default install folder, and it answers in the receipt andpicket.lograther than in the console. The uninstaller runs it too, and listens to the answer: if a file is still hidden it warns you and keeps Picketdesk's records, even when “Delete the application data” was ticked. If Picketdesk is still running, it is first asked to quit (the same full restore as tray → Quit) and the rescue waits up to 15 seconds for it to close completely; one that is still closing by then gets up to 30 seconds more and is never stopped in the middle of its last restore and save — so the files stay restored instead of being re-hidden a moment later by the live instance. That quit usually puts every file back itself: the rescue's window then says so and points you to the receipt the quit wrote, “Picketdesk restored your files.txt”. A Picketdesk that has stopped responding is closed instead; if even that fails, nothing is restored under it, and the uninstaller asks you to endpicket-app.exein Task Manager and retry, or to cancel before anything is removed.
Additional guarantees:
- Only files carrying Picketdesk's signature are ever un-hidden: the paths in
its ledger, plus desktop items still marked
+H+Sor holding Picketdesk's claim marker that no ledger entry accounts for. A file you hid yourself with Explorer's Hidden checkbox (a plain hidden attribute) is never touched, and nothing outside your desktop folders is ever looked at. - An unclean shutdown announces its recovery. An OS
shutdown can kill Picketdesk and its watchdog together, leaving files
hidden until the next launch re-establishes them. That launch now
says so: “Recovered from an unclean shutdown — N hidden file(s)
re-checked; your files are safe”, with the details in
picket.log— and as a Windows notification too, so it reaches you even if that launch has no pickets to show it in. The toast is held until the first picket window is actually up, not fired on a timer, so a slow start cannot lose it. Silence after a reboot means the previous exit was clean. In safe mode the boot pass is suspended, so the message says that instead of claiming a re-check that never happened. - The messages that matter reach you with the pickets hidden. Picketdesk's toasts are drawn inside picket windows, so with hide-all or Focus mode on — or before you have made your first picket — there is nowhere for one to appear. A short list of messages therefore also raise a real Windows notification in exactly those cases: the “Picketdesk can't save right now” warning, a desktop folder that moved or had to be relinked, the result of an organize sweep you asked for (Organize desktop now, from the tray, a picket menu, the palette or Settings), the result of tray → Restore hidden desktop files…, and a background loop that has had to restart itself five times. The sweeps nobody asks for — the daily schedule and Auto-apply every N hours — notify only when they actually moved something; a timer announcing “nothing to organize” every few hours forever is exactly the noise this avoids. Ordinary drag and menu feedback stays a toast on purpose.
- Every hidden file carries a claim marker on disk, alongside the app's own ledger — so even a lost workspace file cannot strand hidden files; a few seconds after each normal launch — and again on every desktop change after that — a sweep finds the files carrying that marker, un-hides them, and reports the count in a toast (safe mode skips the sweep, and so does a read-only session — one whose layout could not be read or whose configuration folder is not reachable — because its record of what is in your pickets is empty or out of date, so every file you filed would look left behind). Anything else hidden on your desktop is left exactly as it is: if you hid a file yourself, Picketdesk will not un-hide it behind your back. Those are listed in Settings → Safety, and the tray entry below clears them.
- Shared PCs:
C:\Users\Public\Desktopbelongs to every account on the machine, so the automatic sweep a few seconds after launch leaves it alone — it cannot tell a file another signed-in user's Picketdesk is looking after from one of your own leftovers, and un-hiding theirs would just make their copy hide it again. The explicit restores (tray, Quit,--restore-icons) still cover that folder, because you asked for them. An item of yours that another account has hidden also stays in your picket: someone else's hide is not a deletion. - Your Desktop is never swapped for the shared one.
When Windows cannot reach your Desktop folder at launch (a Desktop
redirected to a network share that is offline, say), Picketdesk
still treats that folder as your Desktop, and
C:\Users\Public\Desktopstays the shared extra folder it always is. A file dropped onto a picket is never moved into the shared folder in its place: the drop fails with your own folder's error until it is back, and nothing filed from it is unfiled while it cannot be read. - A desktop folder that cannot be read does not stop the
others. When one of the desktop folders cannot be listed (a
C:\Users\Public\Desktopan administrator has locked down, a redirected Desktop that is offline), everything from it stays exactly as it was: nothing filed from it is unfiled, a file you dragged out of a picket stays out, and no rule files anything new there until it can be read again. Rules, Organize desktop now and the clean-up of deleted items carry on for the folders that can be read. - The tray menu has Restore hidden desktop files… — the confirmation shows the count, and every un-hide is logged path by path. If some of those files could not be un-hidden (another program holding one, for example), the result says how many, instead of counting only the ones that came back; Settings → Safety lists the ones still hidden, each with its own Restore.
- A Desktop that moves survives. OneDrive's folder
backup (turned on or off) relocates your whole Desktop folder to
OneDrive\Desktopand back. Picketdesk remembers which desktop folders a layout was saved under; at the next launch every picket item, tag, note and hidden-file record under the old folder is re-linked to the same file under the new one (a toast names the count), and a file still mid-move is kept and retried next launch rather than dropped — never re-linked to a same-named file in the sharedC:\Users\Public\Desktop, which is another file, not yours arriving. Only a Desktop this PC had is re-linked: a layout last saved by another PC names that PC's Desktop, and nothing is moved from it onto same-named files here — nor from a shared layout saved by an older version, which names no PC, unless this PC's own records vouch for its old Desktop. (If those records cannot be read at that start even after a few seconds' wait, that old Desktop is left exactly as it is until a start that can read them.) Folder settings inside the old Desktop follow it too — a self-clean destination, a portal picket's folder and an extra search-index folder point at the same folder under the new Desktop once it is there. One that has not arrived yet (a large folder is often moved last) is retried at every launch until it has, and self-clean never re-creates a folder that has left the old Desktop: those files stay hidden in their picket and a toast says so once, so the archive is never split in two. If the move happens while Picketdesk is running, it pauses desktop scanning and hiding and asks you to quit and reopen — quitting re-links first, then restores your files where they are now, and the receipt lands on the Desktop you are actually looking at. Until you quit, Picketdesk keeps its record of any file it can no longer reach at the old path instead of treating it as gone. Only Windows naming a different Desktop folder counts as a move — including your own Desktop being redirected intoC:\Users\Public\Desktopitself — while a moment when it cannot name yours at all pauses nothing, and is never announced as your Desktop having moved toC:\Users\Public\Desktop. - The Safety section in Settings shows all of this working: watchdog standing by, how many hidden files verify intact on disk, and “If Picketdesk vanished right now, N file(s) would be restored automatically” — counted by the same detector the real restore sweep walks. If a desktop folder could not be read at all, it says that rather than reporting nothing found: an incomplete look is not an all-clear. It checks when you open Settings and whenever that window comes back to the front, and Run self-check re-reads it on demand. Only the newest check can update the panel: a slow earlier reply cannot overwrite its figures or show an old error.
- It names the files it is worried about. The two counts that mean “something is off” — orphaned hidden files, and claims it could not verify — list the file names underneath (hover for the full path), each with Show in folder. An orphan also gets a Restore that un-hides that one file and leaves the others alone, which is the per-file version of tray → Restore hidden desktop files…. It does not ask first: putting a file back can only ever make it visible again. If Windows refuses — a file your account may not edit, or one another program has open — the message says why and that the file is still hidden, and it stays on the list. If the file's folder cannot be read at that moment (a network Desktop that went offline), it says it could not check the file and left it hidden, never that nothing needed doing. Both buttons re-run the same sweep the tray entry uses before they touch anything, so the panel can never un-hide something that sweep would not. The lists stop at 50 names; the counts are always exact, and the tray entry still covers the whole set.
- An item Picketdesk cannot hide says so. A file in
C:\Users\Public\Desktop, whose permissions an ordinary account cannot edit, and a file with a second NTFS name — where the hidden bits live in the shared file record, so hiding it in your picket would hide it everywhere else too — are the two cases Picketdesk gives up on. The item still works in its picket, but its real icon also stays on the desktop, which on its own looks like Picketdesk simply not working on that file. So you get a toast at the moment it happens, naming the file and the reason — it waits for a picket window to be ready rather than being said into an empty room at logon, and comes as a Windows notification if every picket is hidden or Focus mode is on — and the item is listed with that reason, and a Show in folder button, in Settings → Safety for as long as it stays in the picket. Nothing about the verdict is remembered on disk, so you hear it again once per session until the item leaves the picket — which is the fix, and clears the row. - Safe mode (
--safe): manual file actions still work; this is not a read-only file browser. Automatic desktop actions are paused. Every picket shows a banner with “Restore all hidden files” and “Restart normally”, and quitting still restores everything as always. Entering it is explicit — this flag and nothing else, with one exception: a launch that cannot open a single picket window (below). There is no tray entry and no other automatic detection, because while frozen, files you put into a picket stay visible on the desktop and are drawn in the picket, which looks like duplicates. With no picket window nothing is drawn, so there is nothing to duplicate. - A launch that cannot draw its pickets gives your files back. Pickets are drawn by the Microsoft Edge WebView2 Runtime. Picketdesk checks for it before hiding anything: with no runtime it hides nothing and runs in safe mode for that session. If the runtime is there but not one picket window opens (a damaged runtime, a full disk), the files it had just hidden are un-hidden again — only its own, exactly as Quit does — and safe mode keeps them out. A native box says what happened and how many files are back on the desktop; the tray icon keeps working, and the next launch with a working runtime is an ordinary one.
- Quitting comes with a receipt. Tray → “Quit
Picketdesk” restores every hidden file — both the ones Picketdesk has on
record and any
+H+Sorphan nothing accounts for — saves a full backup of your pickets and pages in this PC's backups folder (%APPDATA%\com.picketdesk.app\backups; the newest 10 are kept; Settings → Quit backups → Open backups folder) and writes “Picketdesk restored your files.txt” on the Desktop naming each file and the backup's full path — or saying why no backup could be written. Your files and your layout are kept (only Quit backups older than the newest 10 are removed): relaunch and your pickets come straight back. The uninstaller (via--restore-icons) writes the same itemized receipt. A file Picketdesk could not un-hide — a permission it lacks, a drive that is offline — is listed first, under STILL HIDDEN, with what to do next, and Picketdesk keeps its record of it; the receipt only says “nothing needed restoring” when nothing was hidden at all. Such a file gets one receipt, not one per attempt: the watchdog and the uninstaller's restore try again after the Quit, and write no receipt of their own when all they find is what the Quit's receipt already lists. On a large desktop the restore takes a few seconds; clicking Quit again while it runs just tells you it is working, so the receipt always lists the files that were really put back. The receipt is Picketdesk's own paperwork rather than a desktop item: no rule files it, no smart picket lists it and nothing ever hides it — it stays in plain sight until you read it and throw it away. There is only ever one: each new receipt sends the one before it to the Recycle Bin (never overwritten, since you may have written in it) and takes its name. Only if that one cannot go to the Recycle Bin does it stay, with the new receipt beside it as “Picketdesk restored your files (2).txt”, which is paperwork too — as is anypicket-backup.jsonan earlier version's Quit left on the Desktop, numbered copies included. The restore comes first and the paperwork after it: a receipt that cannot be written is noted inpicket.logand never undoes a restore that already happened.
Pickets and their files not showing? Two steps
Very rarely, a Picketdesk session can get stuck — no pickets on screen, and the files inside them not visible either. It looks dramatic, but nothing has happened to your files: they are exactly where they were, briefly marked hidden, and Picketdesk keeps a precise list of every one. Bringing them back takes seconds:
- Close Picketdesk. Right-click the tray icon and choose Quit Picketdesk — quitting is itself the full restore: every hidden file is un-hidden on the way out. If the tray icon isn't responding, open Task Manager and end Picketdesk; that is the case the watchdog covers — it runs as a separate process, notices the moment the app is gone and shows every file again, usually within a couple of seconds. If anything is still hidden after that, start Picketdesk again: the launch re-checks every hidden file, and tray → Quit Picketdesk then restores them.
- Still missing something? Start menu →
Picketdesk - Restore desktop files (quits Picketdesk)
— it un-hides everything on Picketdesk's list and shows you what it
restored. Belt and braces. (By hand:
"%LOCALAPPDATA%\Picketdesk\picket-app.exe" --restore-iconsfor the default install folder. If even the Start-menu entry is gone, Settings → Apps → Installed apps → Picketdesk → Uninstall runs the same restore before it removes anything.)
Then start Picketdesk again whenever you like. Your pickets, layouts and files all come back exactly as they were — recovering this way never loses a thing.
Reliability, day to day
- Geometry is reconciled from the real windows every second — moves and resizes always survive restarts, even after a crash.
- Z-order: pickets are pinned just above the wallpaper with message-level enforcement — fullscreen apps cannot make the desktop appear empty; a watchdog pulse double-checks every 2 s.
- Rescue from under the wallpaper: Explorer restacks the desktop above the picket band on its own schedule and sends no message about it, leaving a picket on screen with the wallpaper drawn over it. That sunk state is polled every 30 ms for a few seconds after anything that makes Explorer restack, and every 250 ms while things are quiet — so the picket comes back before you can wonder what you did. While no picket is on screen at all (everything hidden, or no picket yet) there is nothing to bury, so it looks only every 2 s, and any picket coming back on screen wakes it at once.
- Every hide and show is logged — including peek-over — so “my pickets disappeared” always has evidence behind it.
- The watchdog recreates windows killed by Explorer restarts; after an Explorer restart, pickets re-tie to the new shell within about a second.
- The background loops restart themselves. The 2 s
self-heal check, the layout saver, the Explorer-restart, z-order and
portal watches, hover reveal and the icon loaders keep running after
an internal error: the error goes to
picket.logwith the loop's name, and the loop starts again after a short pause instead of stopping for the rest of the session. A loop that fails five times says so once, in a notification naming it. - A picket cannot be minimized — it has no minimize box, and no taskbar button or Alt+Tab entry that would bring it back. If another program minimizes one anyway, the watchdog restores it where it was within about 2 s (never while you have it hidden), and its minimized position is never saved as its own.
- A picket cannot be maximized — it has no maximize box, so Win+Up leaves it as it is. If another program maximizes one anyway, the screen-sized window is never saved as its size: the next launch opens it at its own size, not over every other picket.
- Pickets (and free icons) stranded off-screen by
monitor changes are pulled back into view — live, the moment the
display set changes (plug, unplug, resolution, scale), as well as at
startup — including a dock that finishes connecting a few seconds
after you sign in, while Picketdesk is still starting: the pickets
parked for it go back as soon as it is there. A taskbar or app bar that only moves or changes size
(auto-hide on or off, a tablet's taller taskbar, Magnifier docked
at the top) is not a monitor change: pickets whose title bar it now
covers are rescued and return when it moves away, and no docking
profile is applied. Pickets you hid on one monitor stay hidden
unless one of those moves happens: then every monitor scope is
cleared and all the pickets they hid come back (unless hide-all or
Focus mode still hides them), whichever monitor the moved picket
was on, so a moved picket is never left hidden where no toggle
reaches it.
Stranded is judged against each
real monitor, not the virtual bounding box — a picket left in the dead
space of an L-shaped layout counts — and against the part of it the
taskbar leaves free, so a picket whose title bar is behind the
taskbar counts too. Rescued pickets land on the primary monitor,
clear of its taskbar. A moment with no display at all (a disconnected
Remote Desktop session, a console switch) is no information, not
every icon off-screen: the icon rescue moves nothing then. When many
pickets need rescuing, their positions
wrap within that display; their dimensions and original parked
positions are preserved. An oversized picket starts at the display
edge with its title reachable. A loose icon's remembered position
changes only when a real icon has moved: the rescue commands the
icon, reads back where Explorer put it and records that — never a
computed position in its place. The rescue is
undoable: the pre-change layout is filed in the
time machine first, so
a bad transition is one Restore last snapshot
away. Restoring it before the display is back is safe too: a
picket whose snapshot spot is on a display that is gone stays in
view, and returns to that spot when the display does. The same
holds for loading a page and importing a backup made on other
monitors. Monitor memory returns pickets to their
exact spot when a vanished monitor is plugged back in — that
monitor, recognised by its position and resolution, not a projector
or TV that merely covers the old spot. A rescued picket you then
drag onto another monitor (the one at your home desk, say) returns
to that newer spot when that monitor comes back.
Icons outside every picket have no such per-setup memory:
Picketdesk puts back only the ones a monitor change left stranded
off-screen, and only once the new monitor set has held for about
six seconds — a display that only blinks (a Remote Desktop
reconnect, the lock screen, a dock bringing its screens up one by
one) never re-grids your loose icons. Each monitor change records how many loose icons moved
—
monitor change: 7 of 12 free desktop icon(s) moved, worst 830 pxinpicket.log— so if RDP or an undock keeps rearranging yours, that line is the evidence to send with a report. - Mixed DPI / multi-monitor: picket positions are stored in physical pixels. Mixed-scale icon sizing and placement still require validation on the actual display setup.
- Writable-folder checks: compatibility probes create their own new file and preserve any file at an older probe name.
- Icon requests: Unicode path matching is safe at character boundaries. A Rust panic in one request returns a retryable placeholder while the worker remains available for other icons. UI diagnostic messages also preserve complete UTF-8 characters at their length limit.
- Files from other drives: a picket can hold items from a USB stick or a network share, and one is only unfiled when the drive answers and the file itself is confirmed gone. Unplug the stick, drop the VPN or take the share offline and the items wait for it — they just don't draw until it is back.
- Workspace data safety: saves are atomic, and the
rotating backups only change once a save has landed — a run of failed
saves can never overwrite them.
.bakis the previous save; the deeper generations only take a copy that has stood for at least five minutes and.dailykeeps one a day, so they span real time instead of the last few seconds of a drag. A workspace that does not parse — including one re-saved in another text encoding, such as Notepad's “Unicode” — is quarantined, never overwritten, and the newest backup that parses takes over; if nothing is usable the session runs read-only instead of saving an empty file. One that cannot be read at all — antivirus, a backup tool or cloud sync holding it past the few seconds Picketdesk waits at launch — is left exactly where it is, and that session runs read-only with a warning box, showing an earlier save if one parses and saving nothing, so the next launch that can read it carries on from your newest layout. The same protection applies to a backup that cannot be read while recovering a missing or corrupt primary: an older copy may be shown, but that session saves nothing and preserves the unreadable backup for the next launch. The quarantined copy isworkspace.json.corrupt-<stamp>— keep it: it is your layout, and every later launch looks at it and at the rotating backups again, so a missingworkspace.jsonis never mistaken for a fresh start while one of them survives — nor while the folder itself does not answer (a drive not plugged in or not yet unlocked, a network location that has not connected yet): that launch starts empty and read-only with a warning box naming the folder, and saves nothing. - Going back to an older version: every saved file records its format version, and Picketdesk reads it before anything else. An older build that meets a layout from a newer one runs read-only with a warning box: it shows the layout if it can, starts empty if it cannot, and never sets the file aside, never falls back to an older backup and never saves over it. Update again and everything is where you left it. Pages, snapshots and backups made by a newer version are refused with a message, never applied. A layout this version can read keeps any setting in it that this version does not understand: saving writes it back rather than dropping it. Imported backups and picket templates bring in none of them.
Files & storage
Default location %APPDATA%\com.picketdesk.app\ (or the
--profile / cloud-sync redirect target):
| File | Purpose |
|---|---|
workspace.json (+ .bak…,
.daily, .corrupt-*) |
Pickets, assignments, free icons, usage, rules, settings — atomic
writes, time-spaced backups, corrupt-load fallback. What belongs to
this PC — where its pickets and icons sit, which files it hid, its
own settings — is kept in workspace.local.json (below);
the positions and settings here are only the starting point for a
PC with none of its own. Keep any
.corrupt-* copy: it is a layout that did not parse,
and later launches try it again. |
layouts\ / snapshots\ | Pages / time-machine states. |
picket.log (+ .old) | Rolling diagnostics (tray → Export logs…, which takes both).
In the default dir only — never in a synced folder, so each PC keeps its
own. Every line names the process that wrote it ([pid app],
[pid watchdog], …). These processes coordinate rotation
and writes through an empty picket.log.lock sidecar;
a process crash releases its lock automatically. |
redirect.txt |
Cloud-sync pointer (in the default dir only). Followed only when it names a local drive path, so a planted marker cannot redirect your whole configuration to a network share. If the folder it names is missing at launch (drive not mounted, cloud folder moved), Picketdesk waits a few seconds, then starts empty and read-only with a warning box — it never loads an older copy from the default dir in its place. |
ledger.local.json |
Left by earlier versions, which kept the record of hidden
files here. It has moved to %LOCALAPPDATA% (below);
this copy is still read for as long as it exists, and only ever
gets smaller. |
backups\ |
Quit's backups, picket-backup-YYYYMMDD-HHMMSS.json
(the time in UTC): the newest 10 are kept and older ones removed.
In the default dir only — never synced, and never moved by
Move configuration to another folder… — so one
PC's Quits never touch another PC's copies. Settings →
Quit backups → Open backups folder
opens it. |
import-backups\ /
last-import-result.json |
Before every Import…, a complete copy of the
layout and pages it replaces
(picket-before-import-<time>.json); the newest 10
are kept, and each import deletes the oldest beyond that; and the
latest import's result. Beside
workspace.json, so they follow
Move configuration to another folder…. Settings →
Recent import and recovery copies lists them, and
Open recovery folder opens the folder. |
The rebuildable caches live apart, in
%LOCALAPPDATA%\com.picketdesk.app\, and never follow the
redirect: index.sqlite (the search index and its WAL), ocr-cache.json (the image-text transcript),
file-identities.json (the Windows file identity of each
desktop item Picketdesk keeps records for — what proves that a file
renamed in letter case only while Picketdesk was stopped is the same
file, not a different one that took the name) and
icon-cache\ (extracted icons and thumbnails, kept under
512 MB by removing the least recently used first). An
index.sqlite that is no longer a database is set aside as
index.sqlite.corrupt-<time> — kept, not deleted — and a
fresh index is built in its place. They describe
this PC's desktop and hold nothing you could lose, so a roaming
profile never has to copy them at sign-in and a synced folder never hands
one database to two PCs. Existing copies move across on the first launch
that does this; --profile still keeps everything in the one
folder it names.
The same folder holds the records that belong to this PC and
nobody else: workspace.local.json, this PC's own part of the
layout — where each picket and loose icon sits on this PC's screens, the
record of which files this PC tucked into a picket (what Quit, the
watchdog and --restore-icons read to give those files back),
and this PC's own settings: Start with Windows, hotkeys, folders to
index, virtual desktop pages and docking profiles (with the profiles
themselves, in docking\); ledger.local.json, a
second copy of that record; and
page-approvals.json / instruction-approvals.json,
what this PC has approved a page, a zone or a folder to do; and
crash-reports\, the crash reports this PC kept (the newest
20, for at most 90 days) with your choice about sending them —
Settings → Crash reports; nothing in it is sent without
that choice. Not
%APPDATA%: on a company network with roaming profiles or
folder redirection that folder follows the person to every PC they sign
in to, and a record there would be the person's, not the PC's. The first
launch of this version moves the approvals across, and reads a
workspace.json from an earlier version whole and splits it
at the first save (a crash in between loses nothing); deleting the
configuration folder for a fresh start does not delete the record of
hidden files with it.
Troubleshooting
| Symptom | Do this |
|---|---|
| Pickets and their files not showing | The two steps above: close Picketdesk (the watchdog restores everything in seconds), then Start menu → Picketdesk - Restore desktop files (quits Picketdesk) if anything is still shy. |
| Desktop icons missing after a crash / forced shutdown | Start menu → Picketdesk - Restore desktop files (quits Picketdesk), or use tray → Restore hidden desktop files… after the next launch. (Normally the watchdog has already done it for you.) |
| Files look missing on my other PC (synced Desktop) | Fix it on the PC that runs Picketdesk, not the other one:
take the items out of their picket, or quit Picketdesk, or run
Start menu → Picketdesk - Restore desktop files (quits
Picketdesk) there. Un-hiding them on
the other PC (attrib -h -s) does not
stick — while a picket still holds the claim, Picketdesk re-hides
anything that was un-hidden from outside. If your Desktop is
cloud-synced, Picketdesk says so on its
Settings → Compatibility card at startup. |
| Every file in your pickets also shows on the desktop | File Explorer is set to show protected operating system files, which shows the files Picketdesk hid too. Picketdesk never changes that setting for you: in File Explorer open Options → View and tick Hide protected operating system files (Recommended). Settings → Compatibility says so when this is the cause. If only some files show twice, Settings → Safety lists the ones that could not be hidden and why. |
| A box says Picketdesk cannot find the WebView2 Runtime, or could not open any picket window | Your files were left on (or put back on) the desktop. When the runtime is missing, the box offers to open Microsoft's WebView2 page: install the Microsoft Edge WebView2 Runtime from there (the “Evergreen Bootstrapper”). When it is damaged, repair it under Windows Settings → Apps. Then start Picketdesk again. Setup checks for the runtime too, before it installs, stops or removes anything — an upgrade included — and ends with that same offer; uninstalling still works without it. |
| One tile, or every file of one type, shows no icon after Picketdesk closed on its own twice | Picketdesk closed while drawing that file's icon on two
launches in a row, the second time while drawing it on its own —
usually a faulty shell extension for that file type — so it now
skips that icon instead of closing at every start. When the icon
is the one every file of that type shares, every such file goes
without it, and editing a file does not bring it back. Icons that
were only being drawn at the same moment are not skipped.
picket.log names the file. Update or remove the
extension, then tray → Refresh icons to try the
icon again. |
| Something misbehaves and you want Picketdesk inert | Start with picket-app --safe — icons untouched, no
desktop mouse hook. |
| Anything else odd | Tray → Export logs… and attach the zip to an e-mail
to support@picketdesk.com — it holds
picket.log plus your workspace and machine facts. |
Known limitations
- No auto-update or code signing yet — SmartScreen may warn on other machines.
- Private pickets hide content visually; files are not encrypted.
- Content search covers text formats, PDF,
.docx,.xlsx,.pptxand image OCR — not the pre-2007.doc/.xls/.pptformats. A PDF whose fonts use a predefined CJK character map (common when a Japanese, Chinese or Korean font is not embedded) yields no text to search. - Undo covers Picketdesk-initiated moves and deletes — a delete is undone by restoring from the Recycle Bin, so it needs the bin to still hold the file. A conflicting file at the original path does not complete the restore while the selected item remains in the bin; undo stays retryable. External file operations are not covered.
- Custom command zones run exactly what you typed — treat them like a script you wrote.