Keep a Revoked-Mic Failure Log Out of Your First PR Prompt

You cloned the voice repo just after standup, and the staff engineer wants a first pull request before lunch. The bug is narrow: on-device inference still shows a partial result after the user revokes microphone permission mid-utterance. You open a remote coding workspace so an assistant can help you read the failing local test. The laptop log still holds a PCM path, a short transcript, and a debug token from that run.

The phone-side model never needed that workspace, but your prompt can still carry the residue off the device. This checklist splits phone evidence from anything you paste while you learn the repo in the first hour. Treat the steps as a proposed experiment, and replace every placeholder with the handset you actually hold. A conclusion without those fields is a story, not a measurement you can defend in review.

What your first pull request should prove

You are not trying to show that on-device speech is cheaper or more accurate than a hosted model. You are trying to show that a revoke stops capture, drops in-memory samples, and writes a redacted failure row. That row should name the lifecycle transition and the permission state, and it should omit what the user said. Your first rollback should remove the patch without leaving the raw log in either the phone sandbox or the remote workspace.

A single borrowed phone is enough if you write the transition down before you edit any production code. You do not need a device farm, a battery rig, or a latency number you never recorded on this handset. Copy the OS build and framework versions from the device and the lockfile, then keep those strings in the pull request. If the bridge caches a granted flag after the system has already denied the mic, record that as a separate failure.

Decide what the coding server is allowed to see

A remote editor helps when you are new and want a careful review of a small diff. It is the wrong disk for microphone buffers, packaged weights, or an unredacted session log from the failed run. Run inference on the phone, store raw files in an ignored local directory, and send the coding server a skeleton. That skeleton should still let a reviewer follow the bug without reconstructing the spoken words from the session.

Disclosure: This article was prepared as part of MonkeyCode's product outreach. This draft treats free model access and a free server option as operator-supplied availability, not as a verified quota or hardware profile. This article does not name models or token ceilings, because those details were not verified against a primary source here. If you use that server, edit the harness there, then read the current project terms before you depend on the offer.

Safe to paste

• Test name, OS family, and a permission state such as revoked during an active capture.
• Elapsed milliseconds you timed yourself, plus the clock source you used on that specific run.
• Booleans for capture stopped, buffer cleared, and whether the interface recovered, restarted, or stalled.
• Framework and dependency versions taken from the lockfile rather than recalled from memory.

Keep off the server

• PCM, WAV, or Opus paths, and any filename that embeds a session identifier from the failed run.
• Partial transcripts, prompt text, speaker labels, or contact strings taken from the captured utterance.
• Model weight directories, tokenizer files, and any license key shipped beside the packaged model.
• Debug tokens, crash identifiers, and backup paths left behind by the previous local run.

Run the proposed permission-revoke pass

The following pass is a procedure for you to execute, not a result collected for this article. Stop when a step disagrees with the handset, and write the disagreement instead of smoothing it into a pass. Do not claim a recovery you did not watch on that specific device, OS build, and permission path. Leave network, power, and permission state in the notes, because a later reader cannot reconstruct them from a green check.

1. Write the device model, OS build, app version, and speech dependency version into env.txt before you launch.
2. Cold-start the debug build with microphone permission granted and with the network left in a known state.
3. Start a short on-device session and wait until the first partial callback is visible on screen.
4. Revoke microphone permission in system settings while that session is still marked as capturing on the device.
5. Return to the app and note whether capture stopped, the buffer cleared, and the screen avoided transcript text.
6. Force-stop the process, relaunch it, and confirm the sandbox has no new raw audio file from the attempt.
7. Roll the patch back, repeat the revoke, and confirm the old bug returns only as a redacted table row.

Observation table

Use the table as the only artifact you attach to the pull request from this first-hour pass. Leave the observation column blank in the repo template, and fill it on your machine after the run. Do not paste the filled table into a public issue if any cell still contains utterance text. Replace the sample package name before you run a shell command against a phone you do not own.

Step	Expected if the patch holds	Your observation
Revoke mid-session	Capture stops and no new partial is shown
Return to the app	UI names permission loss and hides utterance text
Relaunch	Sandbox has no new raw audio file
After rollback	The bug returns only as a redacted row

Redact the log before the prompt

Run the filter on your laptop before you paste any failure log into a remote assistant prompt. It preserves the shape of the failure while stripping paths, token assignments, and long quoted strings from the file. It is a guardrail for a first pull request, not a guarantee that a clever encoding was fully removed. Read the redacted file yourself, and keep the original log outside any directory the coding server syncs.

#!/usr/bin/env bash
set -euo pipefail

# Proposed local filter. Never aim it at a folder of real user audio.
input="${1:-failure.log}"
test -f "$input"

sed -E \
  -e 's#(/(data|storage|var|Users|tmp)/[^[:space:]]+)#<path>#g' \
  -e 's#([A-Za-z0-9_]*([Tt]oken|[Ss]ecret|[Kk]ey)[A-Za-z0-9_]*=)[^[:space:]]+#\1<redacted>#g' \
  -e 's#"[^"]{12,}"#"<text>"#g' \
  "$input" > failure.redacted.log

echo "Paste failure.redacted.log only. Leave ${input} off the coding server."

Commit the ignore rules with the test so a later rollback does not teach the next junior to check raw logs in. The redacted file is also ignored, because a weak filter can still leave a quote you missed on the first pass. If your editor auto-uploads the workspace, confirm those patterns are excluded before you open the remote project. Treat a sync client that uploads ignored files anyway as a failed setup, not as a minor warning.

failure.log
failure.redacted.log
*.pcm
*.wav
*.opus
session-*/
models/

Android grant line, not a full dump

On Android, record only the permission snapshot, and avoid dumping audio buffers or a full package report. Run the shell check only against a debug package you own, then paste the redacted grant line. A full dumpsys transcript can include paths and identifiers that do not belong in a coding-server prompt. Replace the sample application id with the id declared in this repository before you execute the command.

# Proposed check. Replace the application id with the one in this repo.
adb shell dumpsys package com.example.voice | awk '/RECORD_AUDIO/{print}'

If the grant line is missing, write that absence in the table instead of assuming the permission call succeeded. If adb is unavailable, use the system settings screen and write the same states by hand. Either path still needs the device model and OS build written beside the note you keep. A screenshot of the utterance itself does not belong in the pull request or the remote prompt.

Put a tiny guard in the first patch

The TypeScript below is illustrative pseudocode for a session guard you can adapt to the repo permission bridge. Comments describe the intended branch, and they are not evidence collected from a device in this draft. Ask a reviewer to look for revoke-before-start and revoke-after-stop, which this sketch does not fully model. Keep the function free of string fields that could hold a transcript, a file path, or a debug token.

type SessionPhase = "idle" | "capturing" | "revoked" | "cleared";

export function onPermissionRevoked(phase: SessionPhase): SessionPhase {
  if (phase !== "capturing") return phase;
  // Proposed: stop capture, drop in-memory samples, and skip transcript UI.
  return "revoked";
}

export function failureRow(phase: SessionPhase, elapsedMs: number) {
  return {
    phase,
    elapsedMs,
    transcriptIncluded: false,
    audioPathIncluded: false,
  };
}

You can ask the free model to search the diff for a log line that still interpolates utterance text. Paste the redacted row and the function above, and reject any suggestion that writes the spoken words to disk. Say that rejection in the pull request so the next junior sees the boundary before copying the snippet. If the model proposes a cloud upload for debugging, decline it and keep the failure row local to the device.

Roll back without a leftover file

A first rollback should be dull and complete, not a heroic rewrite of the session stack during lunch. Revert the commit, rerun the ignore check, and search both workspaces for raw audio suffixes and token strings. If the remote workspace still contains the original log or a token from the prompt, delete the file and rotate the token. Clean means both places lack the recording, not merely that the app still compiles after you revert the patch.

Limitations, and who should not use this

This pass does not measure battery drain, thermal throttling, or recognition accuracy, so do not cite it as a benchmark. The filter misses multiline secrets, binary audio, and text hidden as base64, so you still read the redacted file before any upload. iOS and Android revoke at different moments, and a cross-platform bridge may cache a granted flag after the system denial. A React Native or Flutter plugin can also replay a cached partial after process restart, which you should record as its own row.

Do not use this path if your employer forbids source from leaving the laptop, even after a local regex pass. Do not use it when the audio might include health data, financial details, or a child's voice, because redaction is not consent. Do not file a conclusion if you cannot name the device, the OS build, and the permission state you actually changed. Teams that already have a locked-down debug pipeline should keep using that pipeline instead of a personal coding server.

What to attach when you open the pull request

Send the device model, the OS build, the exact revoke steps, and whether the session recovered, restarted, or silently kept a partial. Treat a matching environment as comparable evidence, and treat an unnamed phone as an anecdote rather than a result. If a remote editor would help you draft only the redacted harness, read the current free-server terms before you create the workspace. Leave the raw log on the phone, and ask reviewers to compare your transition notes rather than to rerun private audio.