methodology.md

Methodology

Released 2026-09-11 as v1.0.2 (methodology v0.1). This snapshot is frozen: later corrections and additions ship as a new version with a new tag, never as an edit to the bytes a citation points at — cite the tag or the Digital Object Identifier, not a branch. Two version numbers mean two different things here: the tag names this public snapshot, while methodology v0.1 names the definitions, which stay unchanged until a second provider has been measured (section 7). Every figure quoted in this document set is asserted against the shipped evidence by scripts/analyze.py, which fails when a number and the evidence disagree and warns when a file is edited after the date above.

Methodology v0.1 — the concepts below are frozen. The stage ladder to v0.5, a second provider and a continuous observatory is paper_ai_QoS.md section 7.

Pipeline

Qoder CN installation ──the collector (project tooling)──▶ a local raw dump (not published)
                          │
                 scripts/anonymize.py ──▶ evidence/        (publishable, self-auditing)
                          │
                  scripts/analyze.py  ──▶ analysis/summary_tables.md
                          └── asserts every number quoted in the report

What re-runs, and from what

A claim about reproducibility is worth only as much as the attempt that tested it. Measured on 2026-09-11, against the pinned snapshot raw_snapshots/20260909T183241/ (461 files, SHA256SUMS manifest beginning 4d3c3b5758396e42; the snapshot is not published because it carries local paths and real conversation identifiers):

Step	Command	Result of the attempt
Derived statistics from the published evidence	python3 scripts/analyze.py	reproduces exactly. 62 assertions pass. The output file ends with a content hash plus a second-precision timestamp, and when the hash is unchanged the file is not rewritten at all — so running the checks cannot dirty the tree, and two copies with the same hash hold the same statistics whatever their stamps say
Card against files	python3 scripts/verify_dataset_card.py	reproduces exactly, eight checks, in either repository
Log extracts from the pinned snapshot	the collector with LOGSRC=<snapshot>/logs, then scripts/anonymize.py	does not reproduce the frozen bundle. Of 24 published items, 4 matched byte for byte, 11 differed, and 9 were not produced at all (evidence/screenshots/, evidence/user_statements.md, four extracts, two statistics files, the round-2 directory)

The reasons are concrete rather than mysterious: the error-code dictionary and the model registry are fetched live from the client and the service, so they are point-in-time observations that can move under the pipeline; the screenshot and the operator statements were never derived from logs; and several extracts were added to the collector after the freeze, against the mirror rather than against this snapshot. So the honest framing, used throughout this project: evidence/ is the frozen observation, and everything downstream of it is reproducible. A reader who wants to check a number re-derives it from evidence/; a reader who wants to re-derive evidence/ itself needs the author's unpublished raw tree and the study window still being served by the provider, which no snapshot can guarantee.

Log anchors (how each event class is detected)

Event class	Anchor in ~/.config/QoderCN/logs/**/*.log	Notes
Timeout (80408)	[ChatSessionService] Creating tool_call … {"title":"resume","rawInput":{"chatTask":"CONTINUE_TASK","reasonForCode":80408}}	logged when the banner + resume button appear; the button press adds [ACP] Permission resolved. The banner text itself is never logged (client-side DOM)
Quota/account	ACP session/prompt failed / State transition: streaming -> error / Handling request error for session	each event writes ~3 marker lines a few ms apart; clustered at ≤2 s
Conversation lifecycle (the vendor's task)	task.status.update {"taskId":X,"status":…} in windowN/quest.log (X reappears as executionSessionId; polled via getMasterModeTaskById)	a second, independent stream: its ActionRequired state arrives within 234 ms of every 80408 resume line, which is how report §4.2 attributes timeouts to conversations. Every open window writes the same event (≤0.7 s apart), so (session, status) is de-duplicated at ≤2 s and quest.log never supplies window attribution
Interaction phases	[ACPProgressStateMachine] State transition: A -> B, trigger: T, sessionId: S in windowN/agent.log	one line per phase boundary; the trigger says which (send pressed / first chunk / tool dialog / timeout banner / resume click / turn over). Consecutive transitions of one conversation bound the time spent in each phase (report §4.7). Per-window, not replicated; carries a sessionId, so attribution is direct
Context occupancy per request	Context usage sync received for session S: requestId=…, usedTokens=N, reportedLimitTokens=M (plus Context usage update: {…})	the only real size figure the client exposes, and the only one that matters for a capacity claim — it replaces the transcript-character proxy. Never written to the transcript, and no output-token or cached-input-token count accompanies it
Panel visibility	[ChatViewManagerService] Switched tab: from <view id> to <view id>	the covariate that lets a stall or a wait be attributed to service behaviour rather than to an unobserved panel; measured with it, visibility had no effect (report §9)
Request outcomes baseline	chat_finish:success:200 vs chat_finish:{"code":…}	timeout events produce no chat_finish line at all — the stall evidence

Lines containing "command" are echoes of the investigating agent's own shell commands (the IDE logs tool invocations into the same files) and are filtered out at collection and again at anonymization.

Sources (standard per-user locations)

Source	Supplies
~/.config/QoderCN/logs/	all event timestamps (ms), resume tool calls, quota payloads, model-registry refresh lines, conversation lifecycle (windowN/quest.log), interaction phases (windowN/agent.log)
~/.config/QoderCN/User/error-code-cache.json	the vendor's code→banner-message dictionary (versioned, fetched)
~/.config/QoderCN/User/globalStorage/state.vscdb (ItemTable)	BYOK model definitions (aicoding.customModels), selected context presets (aicoding.modelSelector.runtimeConfig.*), prompt history with timestamps (lingma.chat.localHistory.*)
~/.qoder-cn/cache/projects/*/conversation-history/<sid>/<sid>.jsonl	transcript sizes, entry counts, context-growth curve
/usr/share/qoder-cn-ide/resources/app/product.json	client name/version/commit

Collection rounds and pseudonym namespaces

Round	Span	Published where	Conversation labels
1	2026-09-01 → 2026-09-09	evidence/ — a frozen record of observations, not a build artifact: see "What re-runs, and from what" below	sess-01 … sess-20, numbered by row order in stats/session_size_stats.csv
2	2026-09-10	evidence/incident_20260910/	S1, S2, … assigned by first request in that CSV alone
3	2026-09-11 → ongoing	not published. The same instruments keep collecting while the work is unobserved; whether it becomes a second dataset is an open decision, and if taken it will be a separate directory with its own pseudonym namespace, published as a new dataset configuration rather than an edit to the frozen one	S1… numbering restarts in its own directory, as round 2's does

The namespaces are deliberately not interchangeable and no cross-reference is published, because either one would leak the mapping to real conversation identifiers. Round 2 exists as a separate directory rather than an extension of round 1 because anonymize.py numbers pseudonyms in first-appearance order: any new raw id added to the round-1 input would renumber every later call-NNN and silently invalidate the frozen bundle. A later round is therefore always a new directory, produced with scripts/latency_from_logs.py --since <round start> — that flag is a scope control, not a convenience filter, because the same log tree also carries conversations from unrelated projects.

Measurement caveats baked into the analysis

• The transcript JSONL stores no per-message timestamps and not every prompt; prompt timestamps come from the state DB history instead.
• Per-request context occupancy is logged by the client, as Context usage sync received for session … usedTokens=…, reportedLimitTokens=… (found 2026-09-10; the earlier claim here that no token usage is logged was wrong, because the search covered only usage, prompt_tokens, input_tokens and total_tokens). Still absent: output-token count, cached-input-token count, and any of it inside the transcript. Transcript growth stays a lower bound on request content (system prompt, tool schemas and memory blocks are re-sent but not stored).
• Resume tool-call lines carry no sessionId. Report §4.2 attributes them to a conversation through the ActionRequired transition in windowN/quest.log (1:1, ≤234 ms — see the task-lifecycle anchor above), and to a chat window by the agent.log file the line was found in; no resume event appears in two windows' logs, so the window split is safe to add up.
• The client's watchdog duration is undocumented; only its effect (the banner + resume tool call) is measured. Report §4.3 bounds it from the phase and lifecycle streams (modal 61 s), and §4.7 states why the reset semantics stay inferred: the state machine logs the first chunk of a phase, not each one.
• Phase timings are client-perceived: the prompting interval mixes the client's own context assembly with server latency, so "wait for first chunk" is an upper bound on round-trip, not a network measurement.
• An agent's context cannot be inflated by instruction. Asking it to "read every file" does not grow the conversation: asked for line counts, it ran a counting command and the turn added 851 tokens (report §9). Controlled size sweeps need content the task genuinely requires, or text the operator pastes.
• The client's input queue is invisible. Text typed while a conversation is parked on a banner or a dialog is held, and no log line marks either the hold or the release (zero queue, defer or hold-back markers across every published extract). Send timestamps are therefore dispatch times, never intent times.
• Log retention is size-based, not time-based, and shallow. Each window's agent.log rotates at 5 MiB into a single agent.1.log; the next rotation overwrites it, so the collector's --include='*.log' must run before a window rotates twice or the earliest events are unrecoverable. The published extracts were frozen against raw_snapshots/<ts>/ (a full copy + SHA256SUMS) and are kept current by the project's log mirror, which mirrors each file per-(path,inode) so a rotation-out generation is captured and hashed before it can be overwritten, and re-hashes committed regions on every 3-minute scan to detect any in-place edit of already-written log bytes.
• Adding a stream must not renumber the frozen map. anonymize.py assigns call-NNN to any UUID it has not seen, in first-appearance order, so a new raw extract containing an unknown id would shift every later pseudonym. The quest.log extract is therefore filtered to conversations that already have a row in session_stats/session_size_stats.csv (1 of the 10 task ids in the mirror is dropped, 12 events), and the collector reads LOGSRC=<mirror dir> so a stream can be added from the frozen mirror instead of the live tree, which has already moved past the study window.