# Yunke — isolated owner acceptance, 2026-10-25

Part of the [AI Voice Agent](/docs/modules_handbook/shared/voice-agent/readMe.md).
The latest two-way owner sample was held by the old mapper, then processed through real
API reads after a narrow offline correction. Earlier silent/unanswered samples stay separate.

## Shawn dev CLI self-test, second call — 2026-11-06 19:07 MYT

One more owner call at the owner's request, with the phone awake on the App and the box attached.
The task was created at 19:07:08, the call started at 19:07:32, 24 seconds later, and ended at
19:08:01 after 30 s. One manual watch at 19:10 returned `applied`: Completed, 3 turns, a
340-character summary. Calling and the profile were closed straight after acceptance, and all
five controls and the allowlist by 19:11. One fast sample does not explain the earlier waits.

## Shawn dev CLI self-test, App 2.0.33 — 2026-11-05 21:52 MYT

First call on this phone, this App version and the `zs` dev site, authorized by the owner in
chat for one owner-held number. Setup: sessions saved in the console, the number allowlisted,
Web check ok at 21:50:05, a paused profile (cap 1) allowed locally, then calling, reads, results
and watch on. After-call follow-ups, recording copies, alerts and App reads stayed off.

`voice-agent:yunke-self-test … --database=peta_zs_dev --confirm` ran once. Yunke accepted the
task at 21:52:49 (`created`), so `save` took the sender's `2.0.20` / `20020` headers from an
App 2.0.33 phone. The owner's second handset rang at about 21:57:10, 4 min 21 s later, and the
call ended at 21:58:05 after 56 s. One manual `voice-agent:yunke-watch` the next day at 12:36
returned `applied`: Completed, 8 turns (4 agent / 4 customer), `lead_spoke=true`, a 360-character
summary. The agent spoke the existing cloud script, the training-camp welcome.

Teardown was late: the four controls and the profile stayed on from 21:52 until 12:36 the next
day, because dev has no scheduled watch and the run was not closed that night. No further task
resulted (`yunke_app_call_bindings` stayed at 1). At 12:36 all five controls were paused, the
profile returned to inactive and the allowlist cleared. Sessions stayed saved.

Not verified: call quality, the vendor's dial count, the phone task's final state, no-answer or
busy results, repeated calls, more than one task in a row, or a lock-screen or background run.
Phone number and credentials are not recorded here.

## dev-yc real funnel loop — 2026-10-27 10:00 MYT

First run of the whole business path on the dev-yc test site, with no CLI placement and no
harness: a real landing-page registration into a dedicated test funnel, the real queue, a
separate worker process, the Yunke App API, the bounded Web collection and the ledger.

Setup (09:51–09:54): a paused platform App profile (cap 1, sub-window 10:00–10:20), a
dedicated funnel with one slot, one upcoming physical session and exactly one AI-call
welcome rule (offset 0), no WhatsApp/email/SMS rules; `YUNKE_FUNNEL_QUEUE=yunke` in the
site's `.env` (a lane nothing on the box consumes); the console allowlist set to the one
owner number; read-only session check ok at 09:53:39; reads, results, watch and calling
enabled; after-call follow-ups, recording copies, alerts and App reads off; the profile
allowed locally and the rule switched on.

Run: at 10:00:06 the owner's registration was submitted on the slot landing page
(AI-call consent ticked, WhatsApp consent not) — one registration, one QUEUED send, one
job on the `yunke` lane. At 10:00:45 a one-shot `queue:work redis-ai --queue=yunke --once`
in a networked shell ran `SendFunnelAiCall` (2 s): one create request, accepted by Yunke
at 10:00:47 with a literal parent task ID (`created`), vendor period 10:00–10:20, the send
recorded SENT with the call linkage. Manual `voice-agent:yunke-watch` runs at 10:01 and
10:04 held the binding (`incomplete_explicit_ids`, then `unverified_web_outcome` while the
call was in progress). The owner answered; the call ended at 10:04:07 after 37 s. The
10:04:52 watch returned `applied`: Completed, explicit subTaskId/callActionId bound,
provider call ID set, 5 turns (3 agent / 2 customer, `lead_spoke=true`), a 342-character
summary, `hangupType=2`, the known `end_exceeds_duration` timing flag. Yunke returned
`intentLevel=未明确` again, kept raw by design. `collectWeb()` on the same binding at
10:05:20 returned `duplicate` with an identical snapshot.

Teardown (10:05:25): all five controls paused, the profile inactive, the rule and the
funnel deactivated, the `yunke` lane at 0 (no delayed job), the `.env` line removed.

Observed, for the pilot review: the funnel's thank-you page redirected the browser to a
WhatsApp group invite page (a page open only — no message was sent, and no WhatsApp rule
exists in the test funnel); that redirect is existing funnel behaviour, not Yunke's. Not
verified by this run: the vendor's dial count, the phone task's final state (the owner
checks it in the App; the task expired with its 10:20 period), and the medium/high intent
mapping. Phone number, e-mail and credentials are not recorded here.

## dev-yc console-managed CLI self-test — 2026-10-27 06:13 MYT

First run on the dev-yc test site through the production code path with no harness:
sessions saved in the Yunke management console, read-only Web check ok at 06:11:20, the four
runtime controls enabled from the console, the paused platform profile (cap 1) allowed
locally, then one `voice-agent:yunke-self-test … --database=peta_yc_dev --confirm` at
06:13:34. Yunke accepted the task at 06:13:36 (claim committed, literal parent task ID,
`created`). The owner's handset rang and was answered; the call ended at 06:30:43 after 23 s.
Six manual `voice-agent:yunke-watch` runs between 06:13 and 06:29 held the binding on
`incomplete_explicit_ids`; the seventh at 06:31:36 returned `applied`: Completed, explicit
subTaskId/callActionId bound, provider call ID set, 3 turns (2 agent / 1 customer,
`lead_spoke=true`), a 291-character summary, `hangupType=2`, the known
`end_exceeds_duration` timing flag. Yunke returned `intentLevel=未明确`
(intentSignal 30, confidence 95); the mapper keeps that label raw by design, so no
`intent_level` was written. `collectWeb()` on the same binding at 06:32:06 returned
`duplicate` with an identical snapshot (calls, turns, summary, analysis, settlement time).
All five controls were then paused, the profile returned to inactive and the allowlist
cleared. Not verified by this run: the vendor's dial count, a remote stop, session renewal,
the medium/high intent mapping on this environment, and the phone task's final state (the
owner checks it in the App). No message, follow-up, recording copy or production write
occurred. Phone number and credentials are not recorded here.

## Latest two-way sample — one task/dial, corrected same-call processing

At 21:58:52 placement sent one create request, accepted at 21:58:56. Native polling
produced one automatic dial at about 22:04:48 (355 seconds); subsequent task execution
was paused and verified. The owner explicitly confirmed answering, speaking and hearing
AI replies. No manual supplement or second dial occurred. Original call duration was
156723 ms; native upload/analysis produced 19 turns (10 agent, 9 customer), a 172-character
summary and high intent. Exact App recording and Web result IDs/duration/content agreed.

The old Web mapper supported only connected hangup type 1. This sample's verified
integer type 2 therefore stayed `unverified_web_outcome` without settlement or partial
binding. The monitor deliberately stopped at 22:15:28, 996 seconds after placement,
after cloud data had been read back; phone idle and profile inactive. Its interruption
exit marker is not an upload-before-completion failure. The original automatic run did
not pass, and no corrected ingestion is backdated into that twenty-minute window.

The narrow correction (`1274c2352`, local dev-chen `c41ccbf82`) accepts only verified
integer connected types 1/2 and normalizes high only for exact integer tag 1 in both
sources with matching native/detail high labels and call identity. Unknown/string
values stay held. The regression failed first; 23 tests/526 assertions and Pint/diff
passed with fake vendor HTTP and loopback-only testing MySQL. No standing gate changed.

Subsequent real API reprocessing was scoped exclusively to this existing call/binding,
with four result/detail reads and no task writer or phone control. It returned `applied`
then `duplicate`. Independent DB reads confirmed one call/binding/profile, 157 rounded
seconds, `lead_spoke=true`, high intent, matching summary, all 19 texts/roles/start
offsets, and unchanged turn IDs/settlement on replay. Postprocessing happened after
the phone monitor closed; this is a corrected same-result verification, not a claim
that a frozen corrected version already ran an uninterrupted new live call.

The final native agent span ends at 184378 ms, exceeding duration by 27655 ms. It remains
unchanged with `end_exceeds_duration`. No audio was downloaded/aligned, so final-utterance
delivery and timeline accuracy are not accepted. The current recruitment script, awake
foreground phone and single high tag sample do not prove webinar/business quality,
unattended background operation, message delivery or the complete PDF.

Final exact-task read: status 4, pause 0, redial 0; phone idle. Execution and same-call
processing scopes are disarmed. Formal hours, standing environments/gates and firmware
are unchanged. No App login, petaV3 message, production write, audio download, push or
deployment occurred. Private evidence: `修复版双向自动单通-5039-20261025T215459`.

## Earlier fixed-version test — 21:30–21:44 MYT, recipient reported unanswered

The fixed local dev-chen `bd0c415f5` issued one accepted create request at 21:30:13 with
the new UUID-fingerprint task name. Native execution produced one automatic dial;
the monitor observed it after approximately 653 seconds and confirmed the task's
subsequent work paused. No retry, manual supplement or recording/analysis replay occurred.
The phone had gone asleep; it was woken and the existing App foregrounded before
execution. This sample does not establish unattended background reliability.

The owner answered the observation question with **the recipient did not answer**.
The native answer event/provider completed status and 29560 ms duration do not prove
the person answered: there was one agent opening and zero customer turns. Voicemail or
screening remains an unconfirmed explanation. Native text/start offset (31 ms) matched
the isolated turn. The summary reported no customer response; raw intent `2` stayed
unnormalized and `lead_spoke=false`. This is not a customer-speech or meaningful-intent
acceptance sample, nor a verified vendor no-answer mapping.

At 21:42:19 API collection applied the explicitly related parent/child/action result.
Six subsequent reads returned `duplicate`, retaining one call/binding/turn, stable text
and summary fingerprints, and the original settlement time. Native upload, dialogue,
analysis and result-submit phases all succeeded before intentional shutdown at 21:44:25.
The raw monitor's `operator_or_process_interruption` reason reflects that deliberate
early end after completed post-call work. The isolated profile was inactivated and the
phone idle. Although an App stop command was issued, its process was later visible;
exact-task read confirmed finished status 4, pause 0 and redial count 0.

After being informed the standard 10:00–21:00 window had ended, the owner expressly
authorized this immediate night test. Only the private acceptance process loaded a
model copy with an exception requiring the exact testing DB/profile/window/allowlist
and absolute deadline; ten scoped checks and eight harness checks passed. Formal source
policy and persistent environments were unchanged. Do not ship that private override
or count this as formal-window acceptance. No new App login, message, production write,
recording download, firmware change, push or deployment occurred. Execution is now
disarmed and permission consumed. Bidirectional/full PDF acceptance remains pending.

Private evidence is under `修复版双向自动单通-6659-20261025T203447` in the local research
folder. Only redacted receipts belong in shared docs. The successful fixed-name create
does not recover the original rejection code or prove the earlier rejection's cause.

## Later customer-speech attempt — 18:10 MYT, not dialled

The owner approved a different owner-controlled recipient for one task/dial, up to twenty
minutes, with isolated ingestion/deduplication and no retry/manual supplement. A new empty
461-table schema and eight offline harness checks passed. Opening the existing device
page restored agreement between its connected/authenticated UI and the read-only provider;
firmware remained 0.1.6. The existing phone session and matching Web identity were valid,
and the three prior cloud tasks were terminal. No App login was performed.

At 18:10:20 placement issued one create request; at 18:10:22 the outcome was
`vendor_rejected` / `task_create_rejected`, with no returned task ID. The safety path
stopped the executor at 18:10:23. There were **zero dials**, one isolated refusal/binding,
no turns, no settlement and no result-deduplication test. Follow-up reads confirmed the
same three terminal cloud task IDs, an idle phone and unchanged standing `.env`.

The generated task name was `petaV3 call 1`, already present from the earlier isolated
sample. That cross-database name collision is evidence, not a proven vendor rejection
reason: the original numeric code/message was not retained by the existing adapter.
The follow-up task query's HTTP 200/code 10000 must not be reported as the create response.
No request was replayed to recover diagnostics. Address unique task names and safe error
code retention offline before another separately approved live attempt. The rejected
attempt does not supersede the earlier silent-answer API-path success or prove anything
about customer-speech recognition/intent. Permission for this one attempt is consumed.

## Earlier automatic test — 17:27–17:35 MYT

One task was created by the actual local dev-chen `PlaceAiVoiceCall` / App sender in an
empty isolated database. Native polling produced one automatic dial after approximately
409 seconds; the task's subsequent execution was paused and verified. The App remained
alive for native post-call work. Collection initially held incomplete IDs, then applied
the explicitly scoped parent/child/action result at 17:35:05; repeat collection returned
`duplicate` at 17:35:08. One call, one binding and one turn remained. No manual dial,
recording-save replay or analysis recovery was used. Total observation was 471 seconds.

The native duration was 29561 ms, stored as 30 seconds. Its original recording payload
contained one agent turn (begin 30 ms, end 25830 ms); stored text and offset match it.
The summary states the customer did not respond. Although the owner's initial choice
said normal conversation, they then explicitly clarified that they answered and heard
the AI **without responding**. Agent-only transcription is therefore expected, not a
demonstrated mapper loss. Customer speech recognition and meaningful intent were not
exercised; raw intent `2` remains raw rather than guessed as high/medium/low.

The automatic task/result/isolated-settlement/deduplication chain passed for this sample.
Two-way speech, supported business outcomes/effects, media copies and the full PDF still
need their own acceptance. At completion the phone was idle, executor stopped and profile
inactive. Standing `.env` was unchanged. There was no App login, message, production write,
recording download, firmware change, push or deployment. The bounded permission is consumed;
do not create another task or dial to expand this silent-answer sample.

Private evidence is under the local research folder `petaV3完整自动单通-5039-20261025T172609`;
identifiers, credentials, signed URLs and spoken content are not copied into this handbook.

## What it does

The remainder records the earlier 14:00 one-task, one-platform-dial owner test.
The standalone harness ran local dev-chen code in a dedicated loopback MySQL database
containing schema only from the guarded test database. It used a private dummy environment,
no petaV3 production data/credentials, memory-only gates, blocked messages and disabled copies.
The actual application `.env` and standing Yunke configuration were unchanged.

## How it works

All times below are Malaysia time on 2026-10-25.

| Check | Observation | Acceptance |
| --- | --- | --- |
| Preflight | Phone idle, box connected/authenticated, one old terminal task; Web authentication left the existing phone session valid | Passed for this short window |
| Platform placement | `PlaceAiVoiceCall::run` issued one committed App creation request at 14:00:20; literal parent task ID accepted at 14:00:22 | Passed; no creation retry |
| Native execution | Phone began the task at 14:00:53; monitor observed its first dial at 14:00:55, approximately 35 seconds after placement | Passed for this one observation, not an SLA |
| Control acknowledgement | Pause returned HTTP 200/code 10000, but the one-off harness incorrectly required a data field and triggered its stop/hangup protection | Harness failure; independent detail read confirmed pause=1 |
| Owner supplement | Owner reported the first call ended before answering, then manually dialed again successfully; native second activity started 14:01:26 | Manual intervention; not automatic redial or automatic acceptance |
| Explicit result relationship | Web row contained parent/child/call IDs; its call ID matched the manually supplemented call's explicit native cloud action ID | Useful evidence, not a phone/time guess |
| Complete result | Web row had callStatus=3 and callNum/phoneCallCount=1, but lacked hangupType, duration and turnOnTime; detail lacked recording/transcript/summary fields | `collectWeb` held `unverified_web_outcome`; no forced settlement |
| Final stop state | Later task detail reported taskStatus=4, isPaused=0, redialCount=0; phone idle | Task finished; do not claim pause remains 1 or that local pause is remote cancellation |

The pause ACK's missing data is valid in the previously observed control contract.
The mistake was in the temporary execution harness, not evidence of vendor auth failure.
Its helper now accepts that control ACK while still requiring data on queries and
rejecting auth/contradictory responses. Four offline helper regressions passed. No task
or call was repeated to test the fix. The original creation markers remain in place.

The manually successful call was not substituted for the interrupted automatic attempt.
Its provenance is stamped on the isolated row. The observed native session span is not
a verified recording/billing duration. Matching explicit IDs does not establish that the
transcript, summary or intent has reached the cloud or supports current mapper semantics.

An App recording-metadata query failed; it was not treated as empty and was not retried.
That helper did not retain the final failure business code, so the cause is unclassified,
not a confirmed authentication failure. No audio URL was fetched. Passive phone logs
showed null recording URL and upload/cancellation/retry signals, without a verified
successful cloud recording/analysis receipt. They do not establish a specific root cause.

The final isolated DB has one inactive profile, one pending call and one accepted binding;
zero turns, settled bindings, queued jobs or Media copies. Its explicit child/action IDs
remain uncommitted because the mapper's full validation did not pass. Raw IDs and metadata
stay private outside Git. The regular runtime was never enabled. No customer contact,
message, production write, recording download/audio-byte read, firmware change, push or
deployment occurred. No new App login was used. All helper processes ended; no follow-up
daemon or task creation is scheduled by this test.

### Read-only upload/result follow-up (15:04–15:14 MY)

The user separately authorized log/result inspection only. Wireless ADB was restored
at the owner's new address; no phone setting, App login, upload, analysis, task or dial
was triggered. Installed version 2.0.20 / 20020 matches the cached APK SHA-256
`100ffdb27f72b96f82013314e2eb73fe8b4e0501746811c173eb41d3c1f36bc9`.
The current read receipts retain safe business codes/messages before raising errors.

| Evidence | Observed result |
| --- | --- |
| Current Web task/result/detail queries | HTTP 200/code 10000; exact parent/child/call pair, but recording/transcript/summary fields still absent |
| Current App recording metadata query | HTTP 200/code 20000/success=false: recording record not found; an error, not an empty success |
| Same phone session, known successful S2 control | Same endpoint returns code 10000, matching call ID, 28305 ms and three transcript segments; no audio GET |
| Current App task/results/history queries | Code 10000; task finished, matching result has aiAnalysis=0/tipType=0; history has no exact per-call ID match |
| Local audio | Exact native action-ID-to-path link; file exists, 8,240,684 bytes by stat only; zero audio bytes read |

This follow-up classifies the **new** failing response. It does not retroactively recover
the missing business code from the earlier temporary helper. It supports a missing
business recording for this call under the verified identity, rather than a current
general authentication failure. It establishes no commercial API entitlement or tariff.

The passive log timeline is more specific than the earlier upload-signal inventory:

- 14:03:38: manual call ends; native snapshot says AI_CONNECTED.
- 14:03:39.993: AnalyzeReporter starts for this local report. Native task-status/billing
  requests reference the exact action ID; no response line for those requests is seen
  before the process is reinitialized at 14:03:43.913. That restart aligns with the
  previous harness's protective force-stop. There is no successful analysis-completion
  receipt for this report in the inspected log window.
- 14:05:19: the record-detail view sees recordingUrl=null and starts an OSS upload.
- 14:06:31.609: OSS upload logs success. At 14:06:31.610 the view coroutine reports
  `Job was cancelled`. An object-storage success is not a business recording registration;
  no successful media-registration receipt for this sample was found in that window.
- 14:07:52–53: the retry path successfully sends an **empty** summary with tipType=0
  to the result writer, then updates the tag. Code 10000 acknowledges that payload;
  it is not evidence that transcript/summary/intent generation succeeded. The failed-upload
  retry inventory later says zero; that does not prove all post-call work completed.

Cached decompiled code separates media upload/synchronization from analysis and result
reporting. The upload helper has a separate `/call/upload/callFile/callback` synchronization
step; AnalyzeReporter has its own completion/cancellation handling. No write endpoint was
called to test either. The strongest supported explanation is that the prior force-stop
interrupted initial post-call work, and the later view-scoped upload did not complete the
business synchronization after cancellation. The precise server-side outcome and the
exclusive cause are not proved by client logs alone. Do not infer normalized low/no intent
from zero flags or assume the audio is corrupt from a MediaPlayer preparation error.

All standing gates and runtime `.env` remain unchanged/off; no DB/CRM record was touched.
The existing isolated record remains held. These findings supersede only the previous
uncertainty about current error classification/upload acknowledgements, not the original
partial acceptance outcome. Sanitized follow-up evidence is in the private
`手动成功通话只读排查-20261025T144115` folder alongside the owner-test evidence.

### Existing-call recovery (15:34–15:45 MY)

The user then authorized necessary cloud writes for **only this existing manual-success
action ID**. That scope did not permit another task/dial, App login, production or petaV3
write, message, recording download or firmware change. The existing phone session was
reused after checking the verified enterprise identity, terminal task and idle phone.

| Operation | Receipt and independent verification |
| --- | --- |
| Media synchronization callback, once at 15:34:51 | HTTP 200/code 10000; three subsequent recording queries still returned 20000/not found. The callback alone did not create the business recording. It was not repeated. |
| Recording save, once at 15:43:28 | `/phone-ai-call/app/voiceFile/saveRecording` returned 10000. `getRecordingByCallId` then echoed the exact action ID, owner, existing uploaded object and 128774 ms. No audio GET/upload occurred. |
| Analysis, once at 15:43:31 | `/phone-ai-call/app/ai/analyzeCallRecordV4` returned 10000, exact action ID, summary and native medium-intent fields. No billing or empty-result writer was replayed. |
| Independent Web readback at 15:45 | The unique parent/child/call tuple retained `aiRawResult`; callDetail returned the same 205-character summary, existing recording object and tipType=9 / medium intent. Summary/intent/confidence matched the analysis response. No additional result/tag write was needed. |
| Final phone readback | Existing App session still valid after ordinary Web authentication; recording metadata code 10000, taskStatus=4 and phone idle. This is short-window coexistence evidence only. |

The analysis input came from 15 actual native-log utterances: eight AI and seven customer.
Its boundaries were checked against the explicit action-ID repository insert, report-ID
snapshot and single native call session, including that session's prepared greeting and
resolved caller identity. The same reconstruction reproduced the successful S2 analysis
content field byte-for-byte. This verifies the recovered text input, not original audio alignment.

Original per-utterance offsets were unavailable. The recording save therefore used the
SDK's supported empty recordingContent rather than invented timestamps. Cloud recording
content remains an empty string, **not a recovered structured transcript**. The strict
App reader rejects that shape; do not silently turn it into a valid empty dialogue or
clear ingestion holds. The result list still reports aiAnalysis=0 despite persisted
summary/raw analysis, so that flag alone is not a completeness test. Sparse terminal
fields and the original manual-intervention provenance also remain unresolved.

Three bounded cloud writes were made in total, with durable one-shot attempt markers.
Raw IDs, URLs, speech and receipts remain private in `已有通话恢复-20261025T153040`.
All standing gates and the runtime `.env` stayed unchanged/off. No petaV3 DB was accessed;
the isolated pending row was not settled or replaced. The original automatic acceptance
is still partial; this recovery does not turn the manually supplemented call into an
uninterrupted platform roundtrip or complete the PDF's live acceptance.

## Reference usage

This authorization is consumed. Investigate the **existing** sample's upload/result
completeness under the applicable read scope; do not create a replacement task, guess
missing outcome fields, copy a manual outcome into the automatic attempt, or close it
as a customer miss. Another uninterrupted automatic acceptance call needs a new explicit
bounded scope. The candidate's supported identity, expiry, stop and outcome contracts
remain external acceptance items.

The later existing-call authorization permitted only the recovery recorded above. It is
consumed and does not permit repeating its writes. A verified media callback, recording
save and analysis are separate steps; callback success alone was insufficient here.
Further transcript recovery requires the original supported history/offset evidence,
not invented dialogue alignment. Do not guess/replay callbacks or clear holds. A future controlled-test
stop procedure must distinguish phone idle from completion of post-call upload/analysis;
preserve unknown work without a replacement dial if the approved time bound is reached.

Private evidence is under the local `Tancus-REA研究-2026-10-23/App接口验证-2026-10-25/`
folder, in `petaV3真实单通-20261025T135454`. Use the sanitized result/receipt first;
never copy its `private-*` files, environment or real identifiers into fixtures or Git.
The original 491 PHP / 15 frontend offline checks remain unchanged code evidence;
they do not turn this real test into a pass.

## Related files

- [External acceptance pack](/docs/modules_handbook/shared/voice-agent/yunke-live-acceptance.md), [progress](/docs/modules_handbook/shared/voice-agent/yunke-pdf-progress.md).
- [App caller](/docs/modules_handbook/shared/voice-agent/yunke-app-caller.md), [Web results](/docs/modules_handbook/shared/voice-agent/yunke-web-results.md) — real placement and strict association contracts.
- `src/VoiceAgent/Support/YunkeWebCallMapper.php`, `src/VoiceAgent/Services/YunkeAppResultIngest.php` — sparse/unsupported result holds; no mapping was relaxed for this test.
