Status: authoritative for the v4.0.0 release-engineering project, Phase 1
Audit date: performed against live origin refs at the SHAs in the inventory below
Supersedes: the earlier per-area audit that assumed main was the newer line. That assumption was wrong.
main is not newer than v3. All three long-lived branches share one merge-base, and
main is that merge-base. main is the dormant, oldest line; v3 is the modern,
actively-maintained 3.x line; dev is the v4 integration line.
Branch roles are unambiguous and permanent:
dev — the repository default branch and integration line. All feature work lands here.main — the v4 release channel (latest), populated only by promotion from dev. It is
not the default branch, now or after promotion.v3 — the 3.x maintenance line, fed only by cherry-picks, never by promotion.Nothing in this report authorises a reset or force-push of main or v3. v3’s history is the
sole input to 3.x version computation; main is a promotion target, not a branch to be rewritten.
Concretely, per area:
| Area | Winner | One-line evidence |
|---|---|---|
Dependency / toolchain (go.mod, go.sum, .circleci/config.yml) |
v3 | v3 go 1.25.0 + CI golang:1.27.3-alpine; main go 1.24.1 + CI golang:1.24.1-alpine, no publish-image job |
v4-era architecture docs (HONEYDIPPER_CONTEXT.md, FUNCTION_MAP.md) |
dev (and only dev) | present on dev only; absent on both main and v3 |
README.md / docs/README.md |
dev (v4 content); main and v3 are byte-identical at the old content |
README.md sha 8b546ea0 on main and v3; 98c71d3e on dev |
docs/releasing.md |
v3 (then dev variant) | present on v3 (3331 B) and dev (2682 B); absent on main |
Release config .releaserc |
policy-wins (canonical config lands in Phase 2) | three different configs; none is authoritative today |
Tracked coverage.txt |
drop (dev-only artifact bug) | tracked on dev only, 43330 B, committed by d3aea6b, no branch ignores it |
Reconciliation direction: for toolchain/dependency/release-hardening content the flow is
v3 → (main after promotion); for v4 product content the flow is dev → v4 → main.
Nothing is ever reconciled “from main” on the assumption that main is newer — main is the ancestor.
$ for b in main dev v3; do echo -n "$b: "; git rev-parse origin/$b; done
main: 0d4c36e5f7839bac00ab83d15454dbdabb02ddcf
dev: 264bd3fd91815e25f79c88206abc6031b7962064
v3: bec2249b985e05555a00bbed734683f249d57e58
$ curl -s https://api.github.com/repos/honeydipper/honeydipper | jq -r '.default_branch'
dev
Note: the default branch is
dev, notmain(the plan assumedmain).mainis protected but dormant.Decision:
devremains the repository default branch permanently — it is never switched tomain, at promotion or afterwards. “Default branch” (dev) and “release channel” (main,latest) are therefore kept permanently separate.This is operationally load-bearing, not trivia: Renovate reads its configuration only from the default branch, so the canonical
renovate.jsonlives ondevand sets"baseBranchPatterns": ["dev", "v3"](formerlybaseBranches).mainis deliberately not watched — it is a projection ofdev, so updates enter throughdevand reach the release line at promotion; watchingmaintoo would duplicate or conflict every update. Themain/v3copies of the file are inert — Renovate ignores config on non-default branches — and are kept byte-identical only for merge hygiene. Seedocs/release-process.md§1.1, §1.3 and §10.
| Branch | SHA | Module | go directive |
CI default image | publish-image job |
.releaserc branches |
|---|---|---|---|---|---|---|
main |
0d4c36e5 |
.../honeydipper/v3 |
1.24.1 | golang:1.24.1-alpine |
absent | ["main"] |
v3 |
bec2249b |
.../honeydipper/v3 |
1.25.0 | golang:1.27.3-alpine |
present (tag + recovery) |
["main","v3"] |
dev |
264bd3fd |
.../honeydipper/v4 |
1.27.3 | golang:1.27.3-alpine |
present (tag + recovery) |
["main","v3",{dev:beta}] |
Deviation vs. the plan’s state table: the plan recorded dev at cb50cddb (4.0.0-dev.14 era).
dev has since advanced by 4 commits to 264bd3f; the freeze branch was cut from the current tip
(see §7). The dev line advanced, it did not change character:
$ git log --oneline cb50cddb..264bd3f
264bd3f chore(release): 4.0.0-dev.15
1f40320 chore(deps): update module github.com/moby/spdystream to v0.5.1 [security] (#835)
4253549 fix(deps): update module google.golang.org/grpc to v1.83.2 [security] (#833)
bbffa00 fix(deps): update module github.com/go-git/go-git/v5 to v5.19.2 [security] (#689)
main is the merge-base of everything$ for p in "main dev" "main v3" "v3 dev"; do set -- $p; git merge-base --is-ancestor origin/$1 origin/$2 \
&& echo "$1 IS ancestor of $2" || echo "$1 is NOT ancestor of $2"; done
main IS ancestor of dev
main IS ancestor of v3
v3 is NOT ancestor of dev
$ git merge-base --is-ancestor origin/dev origin/main || echo "dev is NOT ancestor of main"
dev is NOT ancestor of main
$ for p in "main dev" "main v3" "v3 dev"; do set -- $p; echo -n "merge-base $1...$2 : "; git merge-base origin/$1 origin/$2; done
merge-base main...dev : 0d4c36e5f7839bac00ab83d15454dbdabb02ddcf
merge-base main...v3 : 0d4c36e5f7839bac00ab83d15454dbdabb02ddcf
merge-base v3...dev : 0d4c36e5f7839bac00ab83d15454dbdabb02ddcf
All three merge-bases are identical and equal to main’s tip ⇒ main is the common ancestor,
v3 and dev are two independent descendants of it.
--left-right --cherry-pick, i.e. patch-equivalent commits collapsed)$ for p in "main dev" "main v3" "v3 dev"; do set -- $p; echo "--- $1...$2 ---";
git rev-list --left-right --cherry-pick --count origin/$1...origin/$2; done
--- main...dev ---
0 224 # only-in-main: 0, only-in-dev: 224
--- main...v3 ---
0 17 # only-in-main: 0, only-in-v3: 17
--- v3...dev ---
17 224 # only-in-v3: 17, only-in-dev: 224
only-in-main: 0 in every pairing — main carries no unique commit relative to either
descendant once patch-equivalent commits are collapsed. There is nothing on main to “keep”
that is not already reachable from v3 or dev.
v3$ git log --left-right --cherry-pick --format='%m %h %ad %s' --date=short origin/main...origin/v3
> bec2249 2026-10-28 chore(release): 3.10.5
> ce63ca3 2026-10-27 docs(release): note how skipped CI directives block v3 releases (#848)
> 50196a2 2026-10-27 fix(deps): build with Go 1.27.3 to address CVE-2026-111943 (#847)
> 89f3a56 2026-10-02 chore(release): 3.10.4 [skip ci]
> d2dc272 2026-10-02 Merge pull request #828 from .../fix/DTSHOPSRE-7816-v3-image-vulnerabilities
> d79749a 2026-10-02 fix(drivers): preserve Ollama tool schemas
> 4c4f0e0 2026-10-01 fix(deps): restore Go 1.25 lint compatibility
> caf8876 2026-10-01 fix(security): remediate v3 image vulnerabilities
> 0f95002 2026-09-28 chore(release): 3.10.3 [skip ci]
> 6d1aae5 2026-09-28 Merge pull request #827 from .../fix/DTSHOPSRE-7816-v3-release-exact-tag
> dc0c7e3 2026-09-28 fix(release): build v3 images from exact tag
> 1d675d3 2026-09-28 chore(release): 3.10.2 [skip ci]
> 00c257f 2026-09-28 Merge pull request #826 from .../fix/workflow-thread-context-race
> 0e59990 2026-09-28 fix(workflow): synchronize thread context snapshots
> 7735358 2026-03-19 chore(release): 3.10.1 [skip ci]
> 014ef36 2026-03-19 ci: semantic release for v3 (#688)
> aa8651b 2026-03-19 fix: sync creating parallel childs to avoid concurrent map access (#687)
These are security remediations and release-pipeline hardening, dated after main’s last
touch — the empirical proof that v3, not main, is the modern maintenance line.
$ git diff --stat origin/main origin/v3 -- go.mod go.sum .circleci/config.yml
.circleci/config.yml | 176 ++++++++++++++++++++++++++++++++++++++++-
go.mod | 123 ++++++++++----------
go.sum | 314 +++++++++++++++++++++++++++++++---------------------------
3 files changed, 383 insertions(+), 230 deletions(-)
go.mod / go.sum$ for b in main v3 dev; do printf "%-5s module=%-52s go=%s\n" "$b" \
"$(git show origin/$b:go.mod | sed -n 's/^module //p')" "$(git show origin/$b:go.mod | sed -n 's/^go //p')"; done
main module=github.com/honeydipper/honeydipper/v3 go=1.24.1
v3 module=github.com/honeydipper/honeydipper/v3 go=1.25.0
dev module=github.com/honeydipper/honeydipper/v4 go=1.27.3
$ for b in main v3 dev; do printf "%-5s go.sum lines=%s\n" "$b" "$(git show origin/$b:go.sum | wc -l)"; done
main go.sum lines=699
v3 go.sum lines=681
dev go.sum lines=757
$ git diff origin/main origin/v3 -- go.mod | head -24
module github.com/honeydipper/honeydipper/v3
-go 1.24.1
+go 1.25.0
require (
- cloud.google.com/go v0.120.1 // indirect
- cloud.google.com/go/pubsub v1.49.0
- cloud.google.com/go/spanner v1.80.0
- cloud.google.com/go/storage v1.51.0
+ cloud.google.com/go v0.123.0 // indirect
+ cloud.google.com/go/pubsub v1.50.1
+ cloud.google.com/go/spanner v1.87.0
+ cloud.google.com/go/storage v1.56.0
github.com/DataDog/datadog-go v4.8.3+incompatible
...
- github.com/googleapis/gax-go/v2 v2.14.1
+ github.com/googleapis/gax-go/v2 v2.17.0
Every changed dependency line moves forward from main to v3. Nothing moves backward.
v3 is a strict dependency superset-in-time of main.
.circleci/config.yml$ for b in main v3 dev; do echo -n "$b default image: "; \
git show origin/$b:.circleci/config.yml | grep -m1 'image: golang' | sed 's/.*image: //'; done
main default image: golang:1.24.1-alpine
v3 default image: golang:1.27.3-alpine
dev default image: golang:1.27.3-alpine
$ # job presence
main publish-image=0 approve-gates=(none) recovery-filter=(absent)
v3 publish-image=3 approve-gates=approve-v3-release
dev publish-image=3 approve-gates=approve-dev-release
Recovery-path filters (verbatim):
# origin/v3 — publish-image-recovery
filters: |
pipeline.parameters.release_tag != ""
and (pipeline.git.branch == "v3" or pipeline.git.branch == "main")
# origin/dev — publish-image-recovery
filters: |
pipeline.parameters.release_tag != ""
and (pipeline.git.branch == "dev" or pipeline.git.branch == "main")
main has no publish_release_image workflow at all — it cannot publish an image, and cannot
recover one. v3’s recovery filter already covers v3 or main, which is exactly the surface
Phase 5 needs.
main lint image = golangci/golangci-lint:v1.64.8-alpine (integration job image: golang:1.26.0-alpine)
v3 lint image = golang:1.26.10-alpine + go install golangci-lint@v1.64.8 (with comment: golangci-lint v1
cannot read go1.27 export data, keep linting on go1.26 — CVE-2026-111943 fixed)
dev lint image = golangci/golangci-lint:v2.15.0-alpine
Area A verdict: v3 wins. Reconciliation must never overwrite go.mod/go.sum/
.circleci/config.yml on v3 with main’s content. When main becomes the v4 line (Phase 3),
its content comes from v4/dev, and the v3 toolchain hardening stays on v3.
$ for f in HONEYDIPPER_CONTEXT.md FUNCTION_MAP.md README.md docs/README.md docs/releasing.md; do ...
HONEYDIPPER_CONTEXT.md main ABSENT v3 ABSENT dev present (34306 B, sha 68b5523a)
FUNCTION_MAP.md main ABSENT v3 ABSENT dev present (16136 B, sha f728a6a0)
README.md main present v3 present dev present
main sha 8b546ea0 (7069 B) == v3 sha 8b546ea0 (7069 B); dev sha 98c71d3e (15321 B)
docs/README.md main sha 0d19e377 == v3 sha 0d19e377; dev sha f28ece63
docs/releasing.md main ABSENT v3 present (3331 B) dev present (2682 B)
Correction to the earlier audit: the plan predicted the architecture docs would be
“present on main/dev”. They are on dev only — main never had them either.
$ git show origin/dev:HONEYDIPPER_CONTEXT.md | head -1
# Honeydipper v4 — Comprehensive AI Knowledge Base
$ git show origin/dev:FUNCTION_MAP.md | head -1
# Function Map for Honeydipper v4
Both documents are explicitly v4-scoped: they describe module .../v4, go 1.27.3, the
internal/agent/ service, pkg/workflow/, MCP tooling and the agent conversation contract. None
of that exists on v3 (internal/workflow/ instead of pkg/workflow/, no agent service, no MCP).
Area B verdict: dev wins. Explicit recommendation, recorded as a decision:
Do NOT backport
HONEYDIPPER_CONTEXT.md/FUNCTION_MAP.mdtov3. They are v4 architecture documents; onv3they would be factually wrong (wrong module path, wrong package layout, non-existent services) and would mislead both humans and AI agents that read them as ground truth. If v3 needs orientation material, write a small v3-accurate section/file (v3 module path,internal/workflow/, no agent service) — never a copy of the v4 docs.
README.md and docs/README.md are byte-identical between main and v3 (sha 8b546ea0 /
0d19e377), and dev carries a large v4 rewrite (+326 / -60 on README.md). So README is not
a “main-vs-v3” divergence at all — it is a “v4-vs-v3” divergence, again resolved by dev wins
for v4 content, no backport to v3.
docs/releasing.md is the one doc that exists on v3 but not main — further proof of v3’s
release-engineering maturity, and the natural home for v3-specific release notes.
.releaserc ⇒ POLICY WINS (three-way divergence, none authoritative)$ git show origin/main:.releaserc
{ "branches": ["main"], "plugins": [ commit-analyzer, release-notes-generator, changelog, git, github ] }
$ git show origin/v3:.releaserc
{ "branches": ["main", "v3"], "plugins": [ ... , ["@semantic-release/git", {message: "chore(release): ${nextRelease.version}\n\n${nextRelease.notes}"}], ... ] }
$ git show origin/dev:.releaserc
{ "branches": ["main", "v3", { "name": "dev", "prerelease": true, "channel": "beta" }], ... }
Consequences that matter for the plan:
main’s config knows only about main ⇒ running it on v3 would publish wrong-channel
versions. It is not a superset and not a fallback.v3’s config has no dev entry, so it cannot be shared upward.dev’s config is the only one that already describes all three long-lived branches — but it
does not yet give v3 maintenance-branch semantics. v3 must keep producing stable 3.x.y
patches, so the canonical entry is { "name": "v3", "range": "3.x", "channel": "3.x" }.
Not prerelease: true: in semantic-release that declares a prerelease channel and would
emit prerelease-suffixed versions (e.g. 3.10.6-v3.1), destroying 3.x versioning. The
prerelease flag seen on the published v3 GitHub releases is a consequence of publishing to a
non-default channel, not of a prerelease key. Authoring that entry is a Phase 2 concern
(see docs/release-process.md §2).Area C verdict: policy-wins. No branch’s .releaserc is copied to another during Phase 1.
The canonical config is authored once, in Phase 2, and is the single source of truth. Phase 1
deliberately does not modify .releaserc on any branch.
coverage.txt ⇒ DROP$ for b in main v3 dev; do ...; done
main absent
v3 absent
dev TRACKED size=43330
$ git log --oneline --diff-filter=A -- coverage.txt
d3aea6b feat: stateless workflow engine
.gitignore on all three branches contains only the Go-tool comment block (# Output of the go
coverage tool... at line 11) and no pattern that ignores coverage.txt or c.out. So dev
committed a build artifact by accident, and nothing prevents it from being re-added.
Area D verdict: drop. coverage.txt is a generated artifact (CI runs
REPORT_TEST_COVERAGE=1 make unit-tests and publishes c.out), tracked only on dev. Removal is
a non-code change and is queued for Phase 2 alongside the .gitignore entry; Phase 1 records the
decision only, keeping this PR docs-only.
Q: Was v3.10.5 tagged from v3 or from main?
$ git log -1 --oneline --decorate v3.10.5
bec2249 (tag: v3.10.5, origin/v3) chore(release): 3.10.5
$ git branch -a --contains $(git rev-list -n1 v3.10.5)
remotes/origin/v3
$ git for-each-ref refs/tags/v3.10.5 --format='%(objecttype) %(objectname:short) -> %(*objectname:short)'
commit bec2249 -> # lightweight tag pointing directly at v3's tip
⇒ Tagged from v3. v3.10.5 is the annotated-free (lightweight) tag on the tip of v3.
Q: Do v3.10.2–v3.10.5 share v3’s tag-reachable line?
$ for t in v3.10.0 v3.10.1 v3.10.2 v3.10.3 v3.10.4 v3.10.5; do c=$(git rev-list -n1 $t); \
printf "%-8s %s in-v3=%s in-main=%s in-dev=%s\n" ...; done
v3.10.0 a7e34772 in-v3=yes in-main=yes in-dev=yes # predates the fork: on the common ancestor
v3.10.1 7735358c in-v3=yes in-main=no in-dev=no
v3.10.2 1d675d30 in-v3=yes in-main=no in-dev=no
v3.10.3 0f950029 in-v3=yes in-main=no in-dev=no
v3.10.4 89f3a566 in-v3=yes in-main=no in-dev=no
v3.10.5 bec2249b in-v3=yes in-main=no in-dev=no
⇒ Yes. v3.10.1–v3.10.5 are all reachable from v3 and from nothing else; they sit on one
linear, v3-only tag-reachable line that starts right after v3.10.0 (the last release on the
shared ancestor). This is precisely why v3 history may never be reset or force-pushed: it is
the sole source for 3.x semantic-release version computation.
Q: Is main an ancestor of dev?
$ git merge-base --is-ancestor origin/main origin/dev && echo "main IS ancestor of dev"
main IS ancestor of dev
⇒ Yes. Same for v3: main is an ancestor of v3 too. main is an ancestor of both.
Recorded as the standing baseline for the v3 line, not as work to be done:
| Item | v3 reality |
Policy |
|---|---|---|
go.mod go directive |
1.25.0 |
baseline; do not “upgrade to main’s 1.24.1” — that would be a downgrade |
| CI build/test image | golang:1.27.3-alpine |
baseline (carries the CVE-2026-111943 fix) |
| Lint image | golang:1.26.10-alpine + golangci-lint@v1.64.8 |
deliberate: golangci-lint v1 cannot read go1.27 export data. Pinning lint to go1.26 is intentional, not stale |
| Integration image | golang:1.27.3-alpine + redis:7.0.11-alpine |
baseline |
| Image publishing | publish-image (tag-triggered, exact-tag checkout, immutable, digest evidence) |
present and load-bearing |
main by contrast has go 1.24.1, golang:1.24.1-alpine, a /v3 module path and no
publish-image job. Any “sync main into v3” operation would regress CVEs, the Go directive, and
image publication. That is the mechanical form of the direction correction.
| Ref | Type | Target | SHA |
|---|---|---|---|
archive/v3-pre-promotion |
annotated tag and branch | v3 pre-promotion head |
bec2249b985e05555a00bbed734683f249d57e58 |
archive/main-pre-v4 |
annotated tag and branch | main pre-v4 head |
0d4c36e5f7839bac00ab83d15454dbdabb02ddcf |
archive/v4-freeze |
annotated tag | v4.0.0-dev.14 commit |
f0e411dc9b054df9cdb7a2e78e121b44366bc31c |
archive/v4-freeze-dev.15 |
annotated tag | v4.0.0-dev.15 commit (= current dev tip) |
264bd3fd91815e25f79c88206abc6031b7962064 |
v4 |
branch (short-lived freeze) | dev tip at cut time |
264bd3fd91815e25f79c88206abc6031b7962064 |
Tags are the primary, never-deleted safety net; the archive/* branches are secondary and may
be recreated from their tags at any time:
git fetch origin --tags
git branch -f archive/v3-pre-promotion archive/v3-pre-promotion^{commit}
git push origin archive/v3-pre-promotion
Recovery of the exact pre-promotion trees:
git checkout archive/v3-pre-promotion^{commit} # v3 as it was, forever
git checkout archive/main-pre-v4^{commit} # main as it was, forever
All of the above reproduces with no working tree and no privileges:
git fetch --tags origin
for b in main v3 dev; do git rev-parse origin/$b; done
for p in "main dev" "main v3" "v3 dev"; do
set -- $p
git merge-base --is-ancestor origin/$1 origin/$2 && echo "$1 IS ancestor of $2" || echo "$1 is NOT ancestor of $2"
git rev-list --left-right --cherry-pick --count origin/$1...origin/$2
git diff --stat origin/$1 origin/$2 -- go.mod go.sum .circleci/config.yml
done
git log --left-right --cherry-pick --format='%m %h %ad %s' --date=short origin/main...origin/v3
for t in v3.10.2 v3.10.3 v3.10.4 v3.10.5; do git branch -a --contains "$(git rev-list -n1 $t)"; done
| Plan stated | Observed | Handling |
|---|---|---|
default branch = main |
default branch = dev, and it stays dev permanently |
decision recorded: dev is never switched to main; docs PR based on dev (the actual default/integration branch) |
dev head = cb50cddb |
dev head = 264bd3f (+4 commits, incl. 4.0.0-dev.15) |
freeze branch cut from current tip; archive/v4-freeze kept at dev.14 as planned, plus archive/v4-freeze-dev.15 at the cut point |
| arch docs “present on main/dev” | present on dev only |
recorded as corrected evidence; recommendation unchanged (no backport to v3) |
v3.10.2–5 flagged prerelease:true |
confirmed via Releases API | documented in docs/release-process.md bug-vs-intended matrix |