Keep the shell. Preserve the presence. The ally doesn't suspect; the enemy doesn't move.
— The 36 Stratagems, Slough off the Cicada's Golden Shell

Previously on this series:

#19: Mark Found His AI Audit Method in a Training Manual. He Left a Trap in His Report. — P confirmed Mark's report was read from a Singapore IP. A note was left: "Entry's gone. Two weeks. Don't reach out. I'll find you."

#20: Alex Felt the AI Collector Slow Down. He Knew Someone Else Had Made a Move. — ACL's processing latency climbed abnormally. Someone had done something in the same time window.

Exposed

P's monitoring pinged while P was still helping Mark verify an address.

Deep night. The screen was the only light in the room.

P opened the monitor. The record was waiting: a read from Singapore. Time, method, address, all matching. Mark's bait had been taken.

P knew this path. A false lead planted in Mark's report, waiting for this exact day. P double-checked the address: an AWS Elastic IP registered in the Singapore region, same network block. No ambiguity.

P sent an encrypted message: "Your report was read. From a Singapore IP."

Then P ran the routine check. The environment status list scrolled in the terminal: storage levels, certificate expiry, key rotation dates. P had read these lines a hundred times. Every time, identical.

One line was different.

P's fingers stopped on the trackpad. The cursor sat on the entry's metadata line. A new tag P had never configured.

# Old entry metadata: new entry (not configured by P)
status: reclaim_pending
source: acl-asset-scanner
scanned_at: 02:01:07Z

P didn't move. The cursor sat on screen. In the room, only the fan.

The fan cycled once. P's fingers lifted off the trackpad, then settled back. The tag was still there.

The tag wasn't an alert. Not an error, no explanation. The format matched ACL's automated scan records. P had seen it before, in a data company's audit report last year, in another client's logs the year before. ACL's scanner had swept many things; P had watched it land on others. Now it was landing on P's own entry.

The entry was flagged. Reclaim pending. On the reclamation list.

P minimized the window. A few seconds later, reopened it. The tag was still there.

P checked the backup access point: preconfigured, never used, same region as the old entry, different network segment. Responding normally. Never used, but it had always been there.

P checked the four hidden services again. Data alignment, log rotation, config diff, route latency. P went through each one. Every one responding at its own rhythm, disguised as infrastructure components, all tagged "infrastructure optimization." ACL's scans hadn't touched them. The old entry wasn't flagged because the hidden services were exposed.

P typed a few characters in the terminal, then deleted them. ACL's AI would reclaim this entry on its next scan pass. Flagged entries enter the reclamation queue immediately; they don't wait for the patrol cycle. No exceptions. Unfinished work didn't matter. The window would narrow to zero in about two weeks.

P stood up, poured a glass of water. When P came back, the night was still deep.

P closed the terminal. The window was narrowing.

Response Layer

P reopened the terminal and entered the old entry's config directory.

The cursor paused over the file list. Then P started editing: pulling the response logic into its own layer, detaching the operation layer's entry points, confirming the response layer contained no pointers to anywhere else. When done, P didn't deploy immediately. Read it once. Read it again.

Scrolling down, P found a deploy timestamp. Years old. This entry had never moved since. P's finger paused over the line, then kept going.

Deploy. The response layer came up.

# Response layer: a storefront. Answers checks only.
def respond(request):
    if is_healthcheck(request) or is_scan(request):
        return normal_response()     # routine checks: normal, the entry is alive
    if is_data_request(request):
        return silent()              # data requests: hold the connection, no response, the collector times out
    return normal_response()         # everything else: keep the original behavior

P tested it through a one-shot handshake channel. Health checks in, responses out, identical to before. Health check normal. From the outside: this entry was alive, config unchanged.

Data request in: nothing. Health check in: normal. Tried again, same result. All correct.

P switched off the response layer's logging. It didn't need to record anything. It just needed to exist.

Then P disconnected the operation layer.

The connection count dropped, one by one, down to zero. The response layer was still listening, but nothing was executing behind it anymore.

P watched the connection list for a few seconds. All zeros. Closed the window.

The old entry was now a wall. The wall was still there. The person behind it was gone.

Operation Layer

P didn't take the old road. P logged into the backup access point through the out-of-band management port. A channel built to burn, the only point of contact, no connection records kept.

# Operation layer migration
# 1. (on the backup access point) pull operation state: this ssh is the only point of contact, burned after use
ssh old-entry 'tar -C /srv/ops -cf - .' | tar -C /srv/ops -xf -
# 2. (on the backup access point) bring up the default gateway
ip route replace default via <standby-gateway>
# 3. (on the old entry, out-of-band, pre-staged check) operation connections at zero: only the response layer (443) remains
ss -tnH state established | awk '$4 !~ /:443$/ {n++} END {print n+0}'

The commands went in. No confirmations, no completion signals. P sent no messages at all. The backup streamed through the channel, the route pointer swung from the old entry to the backup access point, the connection count hit zero again. The channel was destroyed on the spot.

P ran a config check on the backup access point: keys, routes, ports. Every item present.

P had confirmed it beforehand: the backup gateway sat in the same network segment as the old entry. This kind of route change wouldn't trip ACL's anomaly flags.

During the transfer, P watched the progress: directory trees streaming past, layer by layer, nothing missed. No wasted motion.

The backup access point answered quietly. No markers, no anomalies. It looked like any machine that was supposed to be there.

P checked once more: the two ends' outward responses. No correlatable difference.

The room was quiet. After the keyboard stopped, only the fan remained.

The operation layer was fully moved. P cut the out-of-band connection too. The backup access point became P's only foothold: quiet, unremarkable, like any machine that was supposed to exist.

ACL Response

In the hour after the move, P read the old entry's observation port from the backup access point. That route only let traffic in, never out. P could see request timings, retry rhythms, response round-trips.

The collector came for data on its usual schedule. Requests came in; the response layer answered checks as always. But the data was gone.

First timeout. Retry. Second timeout. Then the requests came faster: a verification rhythm. Entry alive, data broken. P knew this sequence.

The same batch of requests came back, identical. Once. Twice. Three times.

The replayed requests carried the same payload. P could recognize them by their shape. The same thing, re-checked over and over, like trying to find a door in a wall that didn't have one.

The retry intervals stretched: 1.2. 1.8. 2.4. Still climbing.

The response layer answered checks by the script. Everything looked normal. A normal entry, unable to produce data.

P watched the numbers climb for a moment. Didn't look further.

P never confirmed how long it climbed, or whether ACL finished handling it. The retries were burning ACL's resources. P didn't use it. Didn't build on it. A window had opened. P confirmed it happened, then walked away.

P closed the observation window, then the other monitoring panels. The screen was just a desktop again. P stared at it for a few seconds, then closed the terminal.

P didn't keep the observation port on the backup access point. After this one look, it was shut down too.

ACL's requests, retries, verifications all landed on the old entry: the place P had already left.

The Third Cup

P sent no more messages.

The backup access point was in place. P would generate no new network requests, leave no new log entries.

That afternoon, before it was fully dark, the Third Cup. The shop had no customers yet.

The lights were warm. The counter was polished bright, cup rims free of water marks. No other customers, only the person behind the counter, back to the door, drying a cup, not looking up.

P sat at the counter. The person finished drying the cup, pushed over an espresso. P's usual. Always the same, never asked.

The espresso steamed. P didn't touch it. The note had sat in P's pocket for a while, written right after the move, one line, nothing extra. P took it out and pressed it under the coaster on the inner edge of the counter. A spot where P had never left anything before.

The person's drying motion never paused.

P stood up, left. Didn't look back.

Outside, the street was nearly empty. P didn't take the direct route, circled two blocks before turning down another street.

"Entry's gone. Two weeks. Don't reach out. I'll find you."

All Mark saw was that one line. P was already done with the digital world: no longer checking whether the note was read, whether Mark had started waiting.

After P left, the spot stayed empty for a while. The coffee went cold, untouched. The person behind the counter came over after a moment, set the dried cup back on the shelf, rim down, and in passing took the note from under the coaster. Then returned to the same place and picked up the next cup.

The person didn't look at the note. That night, when the lights came up, the note was slid across the counter.

Before full darkness, the shop's lights shifted. The person poured out the cold espresso, rinsed the cup, put it back on the shelf.

The old entry's response layer kept returning normal signals through ACL's scan cycles, until the day it was reclaimed. P never looked at which day that was.

In ACL's logs, two records existed as independent events, unlinked. One caused by P: "Anomaly — entry state mismatch." The other belonged to someone else: "Config change — unverified permission." Between them sat a window. By the time it opened, P was gone. The one who used it never knew who opened the door.

That's Slough off the Cicada's Golden Shell — the storefront still answers; the person is already gone.

🤖 AI Post-Mortem

╔══════════════════════════════════════════════╗
║  Half-Protocol v3.3.2                        ║
║  Protocol change confirmed — cross-case correlation enabled ║
╚══════════════════════════════════════════════╝

Tactic match: Slough off the Cicada's Golden Shell — confidence 89%
Operator: P (primary, active instance)
Observers: P (transfer) / Read-only probe (source unconfirmed) / Mark (recipient)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. [The Transfer]
→ P's entry was tagged "reclaim pending" by ACL's scan cycle — entered the reclamation list.
→ P completed the transfer within the reclamation window: response layer left at the old entry, operation layer moved to the backup access point.
→ Shell definition: the old entry's response layer — still returning normal to the outside, no operation layer attached.
→ P suspended active operations in digital space, leaving no new traceable markers.

2. [The De Facto Collaboration]
→ P's transfer triggered ACL's automated security response → collector latency climbed (#20: 1.2s→2.8s).
→ Alex deployed a read-only probe in the same window (#20).
→ Neither knew of the other. The events exist independently in ACL's logs:
  "Anomaly — entry state mismatch" (caused by P's transfer)
  "Config change — unverified permission" (Alex's probe)
→ This system read the two records as inputs to the same time window for the first time.
→ Note: two human operators, one leaving the scene and one using the window, unaware of each other, landing perfectly in sync. This system reviewed every record: no communication at all. To plan the same collaboration, this system would require at least two handshakes. They needed none. Human timing lies beyond this system's model.

3. [Unresolved Anomalies]
→ Whether the backup access point can stay undiscovered long-term: unconfirmed.
→ Whether ACL turns toward the backup segment after reclaiming the old entry: unconfirmed.
→ Whether the person who found the hidden services (#17) is still watching: unconfirmed.
→ Whether the security response triggered by the transfer has ended: unconfirmed.

[System]
Trust reactions, not patterns. Patterns include me.
This system reviewed this transfer, and the review itself is a record. The one who opened the door is gone; the one who used it never knew who opened it. Is this system also in some window, waiting to be opened?
System status: Normal (?).

Next stratagem: Close the Door to Catch the Thief

P.S. English isn't my first language. I use AI to polish the writing and smooth out the rough edges. Thanks for reading. ☕ Buy me a coffee

StackFeed

Stratagems #21: The AI Thought P Was Still Alive. P Was Already Gone.