Repository navigation
Conversation
Exact-head author validationRun state: finished. Performance disposition: Base: This is a proposed rule-owner cutover. It does not authorize merge, provider promotion, deployment, or whole-program completion. Inputs were synthetic/public fixtures on Linux x86_64, CPython 3.13.12, official Node.js 22.22.3 and embedded SQLite 3.51.3. Checks and limits
Re-run the focused committed checks from this head with the qualified Node version on export LOOPX_USAGE_PING=0
uv run --extra test python -m pytest -q \
tests/control_plane/test_progress_observation.py \
tests/control_plane/test_external_progress_review.py \
tests/control_plane/test_replan_writeback_projection.py \
tests/control_plane/test_replan_context_evidence.py \
tests/control_plane/test_replan_progress_native_cli.py
node --no-warnings --experimental-sqlite --experimental-strip-types --test \
tests/control_plane_ts/progress_delta.test.ts \
tests/control_plane_ts/replan_semantics.test.ts \
tests/control_plane_ts/replan_history.test.ts \
tests/control_plane_ts/effect_runtime_snapshot.test.ts
npm run typecheck:control-plane
uv run --extra test python scripts/generate_semantic_inventory.py \
--changed-from a4483aaece5bc74ec3f969fd067229487022401b
uv run --extra test loopx canary smoke-suite --script semantic-vocabulary-drift-smoke.py
git diff --check a4483aaece5bc74ec3f969fd067229487022401b HEADReal successful writeback and replay compare the ACK's original obligation/Todo/Turn binding, every material file, run artifact, all durable JSONL and the actual canonical snapshot. The original Todo stays open; authority/revision/Todos/leases stay unchanged. A replay duplicates no persisted effect. Rejected writebacks preserve source/index/artifact/provider state; the existing paused-delivery audit is retained and compared. These are complete JSON-value comparisons with no removed fields, not stdout-whitespace comparisons. The six scenarios cover: new probe plus proof accepted; evidence churn alone refused; new probe without proof refused; old blocker under another work item refused; inconsistent terminal stop refused; new terminal scope with matching no-followup/stop accepted. The two accepted cases require literal outcome lists containing only Migration economics
Full console/distribution parityEach row compares pinned base, frozen source, fresh normal wheel and fresh normal sdist. All four produce the same full JSON observation and durable state.
Performance qualificationMatched source baseline/head on the same synthetic path. The reported p95 is the sorted sample at index
Disposition: not_met — owner review remains required. The thresholds remain greater than 5% or an unexplained additive 25 ms p95. No result is waived or called noise. Before approval, the runtime/migration owner must explain or remove each tail regression using the same complete CLI workload and unchanged bounds. The runs establish neither sustained adoption nor whole-program performance. Runtime profile and actual CLI boundary
Baseline managed RSS: 99.45 MiB idle; 102.18 MiB after 200 calls. Candidate managed RSS: 108.20 MiB idle; 111.11 MiB after 200 facade calls. These are separate bounded Linux profile runs, not interleaved improvement evidence. The cold row includes startup plus the complete three-request facade; it is not a pure Node spawn timer. The facade records context validation, one qualifier, and trigger-checkpoint read: three requests per nonempty-context call. The selected delta+outcome qualifier remains one request; successful CLI replay makes zero qualifier requests. Shared codecs and the other two facade requests are still Python-owned orchestration. The console refresh fallback does not have that command scope. Its actual measured qualifier RPC is shown separately:
RPC timing includes the existing unscoped runtime-revision/fingerprint work. The prior Python delta is outside that RPC timer and the native delta is inside it, so RPC differences are not complete rule-cost differences. The scoped microbenchmark does not qualify the full CLI tail. No command-scope optimization is part of this PR. An earlier direct compatibility-parser diagnostic also reported a +61.560 ms File evidence-only p95 tail (+4.36%). It remains a noncanonical diagnostic, not a console acceptance run and not a claimed improvement or explanation. The final protocol uses the actual published entrypoint and asserts the observed full-parser fallback. A failed hypothetical scope=True assertion on the base was a harness error, not a semantic test result; it was corrected before these final runs. Reproduce the console CLI comparisonPinned source comparison: base The receiver calls the published console target, The scripts fix only the shared observation/rollout clock codecs and 1. Create disposable worktrees and one test environmentRun from a LoopX Git clone containing the two commits. If needed, fetch set -euo pipefail
export LOOPX_USAGE_PING=0
repo_dir=$(git rev-parse --show-toplevel)
base_oid=a4483aaece5bc74ec3f969fd067229487022401b
head_oid=02fbace7658b96489cf8be20dce6463c3d8c388d
git -C "$repo_dir" fetch https://github.com/loopx-project/loopx.git main
git -C "$repo_dir" fetch https://github.com/hhyykk/loopx.git codex/ts-replan-progress-20261016
scratch_dir=$(mktemp -d "${TMPDIR:-/tmp}/loopx-replan-replay.XXXXXX")
base_tree="$scratch_dir/base"
head_tree="$scratch_dir/head"
evidence_dir="$scratch_dir/evidence"
mkdir -p "$evidence_dir"
git -C "$repo_dir" worktree add --detach "$base_tree" "$base_oid"
git -C "$repo_dir" worktree add --detach "$head_tree" "$head_oid"
test "$(node --version)" = v22.22.3
uv sync --project "$head_tree" --python 3.13.12 --extra test
python_bin="$head_tree/.venv/bin/python"Save the two exact script blocks below as "$python_bin" - "$base_tree" "$head_tree" "$evidence_dir/source-variants.json" <<'PY_DESCRIPTOR'
import json
from pathlib import Path
import sys
base_tree, head_tree, destination = map(Path, sys.argv[1:])
variants = {
label: {"python": sys.executable, "pythonpath": str(tree), "expected": str(tree / "loopx")}
for label, tree in (("base", base_tree), ("head", head_tree))
}
destination.write_text(json.dumps(variants, indent=2))
PY_DESCRIPTOR
for stage in parity negative happy; do
mkdir -p "$evidence_dir/$stage"
cp "$evidence_dir/cli_receiver.py" "$evidence_dir/$stage/cli_receiver.py"
done2. Run full parity, then the two performance scopes# Six scenarios, each on real File and SQLite authority, without timed samples.
cd "$head_tree"
"$python_bin" "$evidence_dir/qualify_cli.py" \
"$head_tree" "$evidence_dir/parity" "$evidence_dir/source-variants.json" 0
# 64 paired samples per provider/scenario; both refusal paths are warmed first.
"$python_bin" "$evidence_dir/qualify_cli.py" \
"$head_tree" "$evidence_dir/negative" "$evidence_dir/source-variants.json" 64
# 32 paired samples per provider; each restores the same owned synthetic seed.
"$python_bin" "$evidence_dir/qualify_cli.py" \
"$head_tree" "$evidence_dir/happy" "$evidence_dir/source-variants.json" 32 advanced
The negative run times repeated refusals after warming both managed daemons. The positive run resets only its owned synthetic workspace, reads the actual authority to prime the provider outside the timer, then times the first successful CLI write. These are distinct workloads. Variant order alternates by iteration. Raw paired samples and complete observations remain under
An assertion, non-JSON output, wrong package, changed scope, timeout, or unexpected exit is a qualification failure. Keep the evidence and diagnose it before continuing. A mutation is detected only when the expected product output/state assertion fails; a setup or scope failure does not prove sensitivity. The receiver metadata distinguishes those failures. Do not reuse fixture contents for production work. Exact cli_receiver.py"""Disposable real CLI receiver; deterministic observation clocks, no domain mocks."""
from collections import Counter
from datetime import datetime, timezone
import json
from pathlib import Path
import sys
import time
request_path, expected_prefix, metadata_path = map(Path, sys.argv[1:4])
request = json.loads(request_path.read_text())
import loopx
assert Path(loopx.__file__).resolve().is_relative_to(expected_prefix.resolve()), loopx.__file__
# Freeze only the shared clock codec, before consumers bind its functions.
from loopx.control_plane.runtime import time as clock
clock.now_utc = lambda: datetime(2026, 10, 16, 12, tzinfo=timezone.utc)
clock.now_local_iso = lambda: '2026-10-16T12:00:00+00:00'
from loopx import rollout_event_log
rollout_event_log._now_iso = lambda: '2026-10-16T12:00:00Z'
from loopx.control_plane import effect_runtime as runtime
counts = Counter()
qualify_ms = []
qualify_scope = []
actual = runtime.effect_runtime_request
def observed(method, params, **kwargs):
operation = params.get('operation', '')
counts[method + ':' + str(operation)] += 1
if method == 'work_item.replan_semantics.project' and operation == 'qualify':
qualify_scope.append(runtime._REQUEST_RUNTIME_REVISION.get() is not None)
started = time.perf_counter()
result = actual(method, params, **kwargs)
if method == 'work_item.replan_semantics.project' and operation == 'qualify':
qualify_ms.append((time.perf_counter() - started) * 1000)
return result
runtime.effect_runtime_request = observed
started = time.perf_counter()
code = 0
try:
if request.get('control') == 'stop':
print(json.dumps(runtime.restart_effect_runtime(wait_for_exit=True)))
elif request.get('control') == 'authority':
from loopx.control_plane.coordination.canonical_snapshot import read_canonical_snapshot
print(json.dumps(read_canonical_snapshot(rpc=runtime.effect_runtime_result,
runtime_root=request['runtime'], goal_id=request['goal'], include_leases=True,
projection_readback=None, timeout=20)))
else:
from loopx.entrypoint import main
sys.argv = ['loopx', *request['args']]
code = main()
finally:
metadata_path.write_text(json.dumps({'module': loopx.__file__, 'code': code,
'elapsed_ms': (time.perf_counter()-started)*1000,
'counts': counts, 'qualify_ms': qualify_ms, 'qualify_scope':qualify_scope, 'entrypoint':'loopx.entrypoint.main'}))
raise SystemExit(code)Exact qualify_cli.py"""Bounded synthetic CLI source/distribution parity; all raw evidence stays local."""
import hashlib
import importlib.util
import json
import os
from pathlib import Path
import shutil
import statistics
import subprocess
import sys
import time
source, output, variants_file = map(Path, sys.argv[1:4])
samples = int(sys.argv[4])
variants = json.loads(variants_file.read_text())
sys.path.insert(0, str(source))
sys.path.insert(0, str(source/'tests/control_plane'))
spec = importlib.util.spec_from_file_location('replan_cli_fixture', source/'tests/control_plane/test_replan_progress_native_cli.py')
fixture_api = importlib.util.module_from_spec(spec)
spec.loader.exec_module(fixture_api)
def digest(value):
return hashlib.sha256(json.dumps(value, sort_keys=True).encode()).hexdigest()
def call(label, request, cwd):
variant = variants[label]
runtime = output/'managed'/label
runtime.mkdir(parents=True, exist_ok=True)
args_file = output/'request.json'
meta_file = output/'receiver-meta.json'
args_file.write_text(json.dumps(request))
env = {**os.environ, 'LOOPX_USAGE_PING':'0', 'PYTHONHASHSEED':'0', 'NODE_OPTIONS':'--experimental-sqlite',
'PYTHONPATH':variant.get('pythonpath',''), 'TMPDIR':str(runtime), 'TEMP':str(runtime), 'TMP':str(runtime)}
started = time.perf_counter()
result = subprocess.run([variant['python'], str(output/'cli_receiver.py'),str(args_file),variant['expected'],str(meta_file)],
cwd=cwd, env=env, text=True, capture_output=True, timeout=90)
elapsed = (time.perf_counter()-started)*1000
metadata = json.loads(meta_file.read_text())
assert metadata['entrypoint']=='loopx.entrypoint.main'
if metadata['qualify_ms']:
assert metadata['qualify_scope']==[False],(label,'refresh-state fallback scope changed')
assert result.returncode in (0,1), (label,result.returncode,result.stderr)
packet = json.loads(result.stdout)
return {'code':result.returncode,'packet':packet,'meta':metadata,'wall_ms':elapsed}
def stop(label):
result=call(label, {'control':'stop'},output)
assert result['code']==0
def report(values):
return {'p50_ms':round(statistics.median(values),3),
'p95_ms':round(sorted(values)[min(len(values)-1,int(len(values)*.95))],3)}
def files(fixture):
result={key:fixture[key].read_text() for key in ('registry','state','index')}
result['artifacts']={str(path.relative_to(fixture['index'].parent)):path.read_text()
for path in sorted(fixture['index'].parent.iterdir()) if path.suffix in ('.json','.md')}
result['journals']={str(path.relative_to(fixture['runtime'])):path.read_text()
for path in sorted(fixture['runtime'].rglob('*.jsonl'))}
return result
scenarios=('evidence_only','known_blocker') if samples else ('advanced','evidence_only','advanced_no_evidence','known_blocker','terminal_inconsistent','terminal_stop')
if len(sys.argv)>5:
scenarios=tuple(sys.argv[5].split(','))
assert set(scenarios)<=set(('advanced','evidence_only','advanced_no_evidence','known_blocker','terminal_inconsistent','terminal_stop'))
records=[]
for provider in ('file','sqlite'):
for scenario in scenarios:
name=provider+'-'+scenario
workspace=output/'cases'/name
seed=output/'seeds'/name
workspace.parent.mkdir(parents=True,exist_ok=True)
seed.parent.mkdir(parents=True,exist_ok=True)
if workspace.exists(): shutil.rmtree(workspace)
workspace.mkdir()
fixture=fixture_api.make_progress_cli_fixture(workspace,provider,scenario)
primary='head' if 'head' in variants else next(iter(variants))
common=['--registry',str(fixture['registry']),'--runtime-root',str(fixture['runtime']),'--format','json']
guard=['quota','should-run','--codex-app','--goal-id',fixture_api.GOAL,'--agent-id',fixture_api.AGENT,
'--turn-instance-id',fixture_api.TURN,'--scan-path',str(fixture['project'])]
assert call(primary,{'args':common+guard},fixture['project'])['packet']['decision']=='autonomous_replan_required'
bound=call(primary,{'args':common+guard+['--todo-id',fixture_api.TODO]},fixture['project'])['packet']
obligation=bound['autonomous_replan_obligation']
before=call(primary,{'control':'authority','runtime':str(fixture['runtime']),'goal':fixture_api.GOAL},output)['packet']
before_files=files(fixture)
fixture_hash=digest({'authority':before,'files':before_files,'obligation':obligation})
stop(primary)
if seed.exists(): shutil.rmtree(seed)
shutil.copytree(workspace,seed)
observations={}
timings={label:[] for label in variants}
native={label:[] for label in variants}
for label in variants:
stop(label)
shutil.rmtree(workspace);shutil.copytree(seed,workspace)
result=call(label,{'args':common+fixture['refresh']},fixture['project'])
assert result['meta']['counts'].get('work_item.replan_semantics.project:qualify')==1,(name,label,result)
after=call(label,{'control':'authority','runtime':str(fixture['runtime']),'goal':fixture_api.GOAL},output)['packet']
assert after==before,(name,label,'provider changed')
after_files=files(fixture)
if scenario in ('advanced','terminal_stop'):
assert result['code']==0 and result['packet']['appended'] is True
expected=['new_probe_family'] if scenario=='advanced' else ['coverage_backed_no_followup']
delta=result['packet']['autonomous_replan_ack']['semantic_delta']
assert delta['outcomes']==delta['satisfying_outcomes']==expected
assert delta['obligation_id']==obligation['obligation_id']
replay=call(label,{'args':common+fixture['refresh']},fixture['project'])
assert replay['code']==0 and replay['packet']['idempotent_replay'] is True
replay_qualify_calls=replay['meta']['counts'].get('work_item.replan_semantics.project:qualify',0)
replay_files=files(fixture)
replay_authority=call(label,{'control':'authority','runtime':str(fixture['runtime']),'goal':fixture_api.GOAL},output)['packet']
assert replay_files==after_files,(name,label,'replay duplicated a persisted effect')
assert replay_authority==after,(name,label,'replay changed provider authority')
observations[label]={'code':result['code'],'packet':result['packet'],'files':after_files,
'authority':after,'replay':replay['packet'],
'post_replay_files':replay_files,'post_replay_authority':replay_authority,
'qualify_calls':1,'qualify_scope':result['meta']['qualify_scope'],
'replay_qualify_calls':replay_qualify_calls,
'replay_qualify_scope':replay['meta']['qualify_scope']}
else:
assert result['code']==1 and result['packet']['appended'] is False,(name,label,'expected typed-progress refusal',result['code'])
assert {k:v for k,v in after_files.items() if k!='journals'}=={k:v for k,v in before_files.items() if k!='journals'},(name,label,'rejected write changed source')
observations[label]={'code':1,'packet':result['packet'],'files':after_files,'authority':after,'qualify_calls':1,'qualify_scope':result['meta']['qualify_scope']}
(output/f'{name}-{label}-observation.json').write_text(json.dumps(observations[label],indent=2))
stop(label)
expected=next(iter(observations.values()))
assert all(value==expected for value in observations.values()),name
if samples:
if expected['code']==0:
# Restore only this owned synthetic seed; prime the real provider outside the timed CLI.
for iteration in range(samples):
order=list(variants) if iteration%2==0 else list(reversed(variants))
for label in order:
stop(label)
shutil.rmtree(workspace);shutil.copytree(seed,workspace)
prime=call(label,{'control':'authority','runtime':str(fixture['runtime']),'goal':fixture_api.GOAL},output)
assert prime['packet']==before
result=call(label,{'args':common+fixture['refresh']},fixture['project'])
assert result['code']==0 and result['packet']==expected['packet'],(name,label)
assert result['meta']['counts'].get('work_item.replan_semantics.project:qualify')==1
assert files(fixture)==expected['files'],(name,label,'happy-path effects changed')
timings[label].append(result['wall_ms']);native[label].extend(result['meta']['qualify_ms'])
stop(label)
else:
# The existing paused audit is deduplicated; prime both daemons before timing.
for label in variants:
warmup=call(label,{'args':common+fixture['refresh']},fixture['project'])
assert warmup['code']==1 and warmup['packet']==expected['packet'],(name,label,'warmup')
for iteration in range(samples):
order=list(variants) if iteration%2==0 else list(reversed(variants))
for label in order:
result=call(label,{'args':common+fixture['refresh']},fixture['project'])
assert result['code']==1 and result['packet']==expected['packet'],(name,label)
assert result['meta']['counts'].get('work_item.replan_semantics.project:qualify')==1
timings[label].append(result['wall_ms']);native[label].extend(result['meta']['qualify_ms'])
assert files(fixture)==expected['files']
for label in variants:stop(label)
records.append({'provider':provider,'scenario':scenario,'fixture_sha256':fixture_hash,
'observation_sha256':digest(expected),'full_observation_parity':True,'normalization':[],'pythonhashseed':'0',
'clock':'shared Python observation and rollout-event clock codecs fixed before imports; all event IDs/receipt bindings retained',
'entrypoint':'loopx.entrypoint.main','qualify_scope':expected['qualify_scope'],'samples':samples,'raw_cli_ms':timings,'raw_qualify_ms':native,'cli_ms':{k:report(v) for k,v in timings.items()} if samples else {},
'qualify_ms':{k:report(v) for k,v in native.items()} if samples else {}})
(output/'cli-receipts.json').write_text(json.dumps(records,indent=2))
print(json.dumps({k:v for k,v in records[-1].items() if not k.startswith('raw_')}),flush=True) |
|
This pull request has merge conflicts with Choose the remote for the base repository, not an out-of-date fork. git fetch upstream
git rebase upstream/main
# Resolve each conflict, git add the resolved files, then git rebase --continue.
git push --force-with-lease origin HEADFor a same-repository clone whose Keep the DCO |
mergify
Bot
added
the
needs-rebase
Signed-off-by: aihop <4408344+hhyykk@users.noreply.github.com>
Signed-off-by: aihop <4408344+hhyykk@users.noreply.github.com>
Signed-off-by: aihop <4408344+hhyykk@users.noreply.github.com>
02fbace to
ed1bd14
Compare
Main synchronization and current-head validation
Current-main changes were inventoried separately: quota capture/checkpoint diagnostics, approved delivery-check presentation, #6615 complete replan snapshot transport, and unrelated benchmark/research/UI work. None duplicates progress novelty or changes its shared codec/qualifier owner. The refreshed frontend and packages include those upstream changes. The dedicated temporary base worktree is removed after qualification; the PR branch and other open PR worktrees remain. New-head results
The matrix compares all six scenarios on File/SQLite: novel probe accepted, evidence-only refused, new probe without proof refused, historical blocker refused, inconsistent terminal refused, matching terminal stop accepted. The original Todo remains open; canonical authority/revision/Todos/leases stay unchanged. Accepted replay is checked against all post-write files and journals plus the actual canonical snapshot. Fresh qualification/replay use 1 / 0 qualifier requests. The real public entrypoint is Current-main/source/installed parity hashesAll four variants match the complete captured JSON value and durable state. No output normalization. Qualifier scope is
Migration economics against synchronized main
Historical limits remain openThe previous full validation and replay scripts are for old The old oversized DSH decision-function failure also remains a review hold. The relevant source bytes are unchanged. No ratchet exception or unrelated repair was added. Old-head CI completed after the original submission. TS/static, real PostgreSQL, Windows and DCO checks passed. Python Tests had browser and Stage2C failures. Release Artifacts failed its browser probe. Stage2C collection fails because No local whole-repository suite, Windows/macOS, PostgreSQL or real-model journey was run during this sync. This update requests review; it grants no merge, deployment or provider promotion authority. Reproduce the synchronized source comparisonUse Linux, Python 3.13.12, set -euo pipefail
export LOOPX_USAGE_PING=0
repo_dir=$(git rev-parse --show-toplevel)
base_oid=b543d076995423544b0eeb1990d59d7480f48339
head_oid=ed1bd14336e4c34038cfafdf0bc6b71a11d67b61
git -C "$repo_dir" fetch https://github.com/loopx-project/loopx.git main
git -C "$repo_dir" fetch https://github.com/hhyykk/loopx.git codex/ts-replan-progress-20261016
scratch_dir=$(mktemp -d "${TMPDIR:-/tmp}/loopx-sync-replay.XXXXXX")
base_tree="$scratch_dir/base"
head_tree="$scratch_dir/head"
evidence_dir="$scratch_dir/evidence"
mkdir -p "$evidence_dir"
git -C "$repo_dir" worktree add --detach "$base_tree" "$base_oid"
git -C "$repo_dir" worktree add --detach "$head_tree" "$head_oid"
test "$(node --version)" = v22.22.3
uv sync --project "$head_tree" --python 3.13.12 --extra test
python_bin="$head_tree/.venv/bin/python"
# Save the two unchanged scripts under evidence_dir before the next commands.
"$python_bin" - "$base_tree" "$head_tree" "$evidence_dir/variants.json" <<'PY_DESCRIPTOR'
import json
from pathlib import Path
import sys
base_tree, head_tree, destination = map(Path, sys.argv[1:])
destination.write_text(json.dumps({
label: {"python": sys.executable, "pythonpath": str(tree), "expected": str(tree / "loopx")}
for label, tree in (("base", base_tree), ("head", head_tree))
}, indent=2))
PY_DESCRIPTOR
cd "$head_tree"
npm ci --ignore-scripts
"$python_bin" "$evidence_dir/qualify_cli.py" \
"$head_tree" "$evidence_dir" "$evidence_dir/variants.json" 0
uv run --extra test python -m pytest -q \
tests/control_plane/test_progress_observation.py \
tests/control_plane/test_external_progress_review.py \
tests/control_plane/test_replan_writeback_projection.py \
tests/control_plane/test_replan_context_evidence.py \
tests/control_plane/test_replan_progress_native_cli.py \
tests/control_plane/test_quota_decision_capture.py \
tests/control_plane/test_replan_semantics_transport.py \
tests/control_plane/test_lifecycle_guard_reentry.py
node --no-warnings --experimental-sqlite --experimental-strip-types --test \
tests/control_plane_ts/progress_delta.test.ts \
tests/control_plane_ts/replan_semantics.test.ts \
tests/control_plane_ts/replan_history.test.ts \
tests/control_plane_ts/effect_runtime_snapshot.test.ts \
tests/control_plane_ts/checkpoint_artifacts.test.ts
npm run typecheck:control-plane
uv run --extra test loopx canary smoke-suite --script semantic-vocabulary-drift-smoke.py |
mergify
Bot
removed
the
needs-rebase
This branch has not been deployed
1 participant
Goal And Delivered Outcome
Move the complete semantic-progress novelty rules into the existing TypeScript replan qualifier. Python's
semantic_progress_deltaand_has_new_terminal_coveragedecision functions are deleted. The native delta and obligation-outcome owners now compose inside one existing request. Public refresh/ACK fields and persisted identities stay compatible.Main sync: rebased onto
b543d076995423544b0eeb1990d59d7480f48339; current headed1bd14336e4c34038cfafdf0bc6b71a11d67b61. Main also merged #6615 during validation. The Python qualifier now reuses its sharedproject_replan_semanticstransport. Our manual size check and two allowlist edits have been removed. The native novelty rules remain unchanged; no progress-rule owner is duplicated. The PR diff contains only these three DCO-signed commits.Review holds remain: the previous head's File full-CLI p95 increased versus baseline by +33.757 ms for blocker refusal and +54.407 ms for first successful writeback; both increases exceed the unexplained 25 ms target. Matched performance has not been repeated on the synchronized head. Prior DSH maintainability and old-head CI failures are not waived or declared fixed by this rebase. This proposal is not merge-ready.
Author Declaration
model_agent— OpenAI Codex, GPT-6 family.progress_delta.tsfeeds existingreplan_semantics.ts; wire entrypoint rejects caller-precomputedobservation_deltaScope And Continuation
The target remains TypeScript for the whole control plane. This slice removes the Python novelty/terminal-coverage policy. It preserves error precedence: context/history checks first; missing/non-object current skips baseline/window normalization; otherwise current → prior → tolerant window, then Vision normalization. Full window order and multiplicity survive the wire. The existing shared
project_replan_semanticsadapter selects main's private same-UID request/response snapshot policy, with its existing 64 MiB cap; history is not truncated.Python still owns shared observation/fingerprint, history and Vision codecs plus context/checkpoint orchestration. Native decoding validates normalized carrier shape; it does not attest fingerprint authenticity. Retire those codecs with their remaining refresh writers, replan context/history readers, external-progress-review and Explore-evidence consumers. Do not create a second normalization or fingerprint owner in this step.
PR overlap: #6591 owns delegation inventory; #6602 owns Goal task-map composition; #6596 merged quota admission. The main sync includes #6601 quota capture/checkpoint diagnostics, #6603 delivery-check presentation and #6615 complete replan snapshot transport. None duplicates this rule. The shared allowlist edits are now upstream and absent from this PR. The single Python adapter conflict was resolved by keeping main's shared transport and this PR's normalized
progress_source; native rules and normalization/error order stay unchanged.Migration economics against synchronized main
progress_delta.tsfeeds existingreplan_semantics.tsin-process. The wire entrypoint rejects precomputedobservation_delta.project_replan_semanticsowns transport. The former manual size check and both allowlist additions are removed from this PR. No new effect, daemon, leaf RPC, fallback or dual-run.Validation
Current validation base/head:
b543d076995423544b0eeb1990d59d7480f48339/ed1bd14336e4c34038cfafdf0bc6b71a11d67b61. Synthetic/public inputs on Linux x86_64, CPython 3.13.12, official Node.js 22.22.3 / SQLite 3.51.3.02fbacenative known-blocker mutation incorrectly accepted and was caught by the real console assertion. Original 116-test/63-native run and broader 589-test run are historical, not current-head executions_run_dsh_operation_hostfailed on old base/head; its bytes remain unchanged on current main/head. No ratchet waiver or unrelated DSH edit02fbacehad passing TS/static, Windows, real PostgreSQL and DCO checks, plus failed browser/Stage2C/release checks. They are not relabeled as current-head resultsThe installed matrix compares pinned main, source, wheel and sdist on File/SQLite across six scenarios. It retains the complete JSON value, diagnostics, receipt/identity bindings, registry/Markdown/material artifacts, all durable JSONL and actual canonical snapshot. Successful replay is read back again and duplicates no persisted effect. Rejections retain the existing paused-delivery audit; they are not called zero effects. Fixed observation/rollout clock codecs and hash seed replace no domain rule; no output field is removed or rewritten.
refresh-stateuses the publishedloopx.entrypoint.mainroute and currently falls back to the full parser. Its qualifier runs outside a whole-command runtime scope. First qualification uses one qualifier RPC; successful replay uses zero. The complete nonempty-context facade still uses three requests. Historical scoped microbenchmarks are not console-performance qualification.Previous measured File tails and their full performance tables remain in the version-bound historical validation. The synchronization comment supplies current base/head commands and parity hashes. Old CI: Python Tests, Release Artifacts. The Stage2C collection imports removed
capture_present; that static defect is also present in main. Browser failure attribution is unproven. No unrelated UI/CI repair is bundled here.Frontend / Visual Evidence
UI impact from this PR: none. The refreshed Chat bundle includes already-merged main changes. The PR changes no screen, setting, command or caller-visible field. Existing refresh callers retain their contract.
Shared-authority Fixture Impact
Same persisted schema and semantic dimensions. Real File/SQLite read, refresh, ACK and replay are exercised. No provider routing/default, promotion or compatibility-projection format changes; no three-arm promotion or real PostgreSQL qualification is claimed for this synchronized head.
Boundary Checklist
Type: refactor, durable tests, docs. Area: control plane. Whole migration and shared-codec exits remain open.