Recently, I have been continuing to process the remaining historical articles according to the currently primary WordPress historical article processing SOP.
This SOP has undergone multiple rounds of validation with real batches. The current daily workflow roughly consists of fixed batches, Gutenberg normalization, production read-only verification, Chinese excerpt generation, English override translation, failure recovery, and final completed status confirmation.
An earlier phase of the workflow is documented in Batch Processing 20 WordPress Historical Articles Daily: A Complete SOP for Code Block Migration, Excerpt Completion, and English Override Translation.
As work on subsequent historical articles continues, my actual operations now primarily reference the SOP updated on July 30, rather than starting over from the earliest workflow.
A few days ago, I actually encountered a situation where automated processing could not complete successfully, and I ultimately switched to manual processing. I chose to have ChatGPT take over the required content, and then manually completed the article processing in WordPress. That process was recorded in a historical article processed manually a few days ago.
Today, while continuing to process a new fixed batch of 20 articles, I encountered another exception scenario better suited for formal inclusion in the SOP:
The automated workflow had not even entered the English override translation phase yet when it continuously received GLM HTTP 400 errors during Chinese excerpt generation.
After multiple real retries, execution evidence checks, and offline analysis, I finally confirmed that this was not ordinary network fluctuation, but rather GLM explicitly triggering content safety filtering.
This time, I did not modify the original historical article to pass the model’s review. Instead, I further refined the existing manual fallback process:
Deterministic rejection by automated model
→ Stop meaningless retries
→ ChatGPT manually generates Chinese excerpt
→ ChatGPT manually completes English title, excerpt, and body
→ Manually write back to WordPress
→ mark-manual-completed production read-only acceptance
→ Preserve original failure evidence
→ coordination state safely converges to completed
Ultimately, this batch still achieved 20 / 20 fully completed.
1. Only One Article Left Out of 20, but Excerpt Generation Continues with HTTP 400
The batch being processed this time was:
mixed-syntaxhighlighter-20260814-03
The entire batch consisted of 20 articles, of which 19 were completed normally, leaving only:
zh=7756
en=10072
The corresponding Chinese article title is:
The Process of Transferring USDT from OKX to MEXC via ARB Cross-Chain
This is a historical operation record. The body contains content such as MEXC, OKX, USDT, Arbitrum One, deposit addresses, withdrawal networks, transaction fees, and arrival records.
This failure occurred earlier than the English translation phase.
The execution evidence shows:
status: excerpt_generation_failed
error: HTTP request failed with status 400
If we only looked at the HTTP 400, it would actually be difficult to determine whether it was:
Request parameter exception
Input content issue
Model service exception
Network fluctuation
Content moderation
Therefore, I continued to examine the saved structured GLM response.
The truly critical information finally appeared:
error.code = 1301
Along with:
contentFilter:
role = assistant
level = 1
The information returned by the model also explicitly pointed to content safety filtering.

1301 content filtering result.At this point, the problem should no longer be treated simply as a “network error.”
2. A Single TimeoutError Cannot Explain the Recurring HTTP 400
During this troubleshooting process, there was indeed one occurrence of:
TimeoutError
So initially, there was a question:
Could it just be that the GLM service was unstable at that time?
However, after putting the entire sequence of failures together, it became quite clear:
HTTP 400
→ HTTP 400
→ HTTP 400
→ recover
→ TimeoutError
→ recover
→ HTTP 400
The TimeoutError in the middle can be viewed independently as a temporary network request exception.
However, the consistently recurring HTTP 400 errors before and after it obviously cannot all be explained by network fluctuation.
The subsequent code also further enhanced diagnostic information, allowing the HTTP status, structured error response, and GLM request size to be included in the execution evidence.
This way, when encountering similar errors in the future, there is no need to stare only at a long Python traceback.
3. After Offline Inspection, Input Length Issues Were Ruled Out
To further confirm the cause, I pulled the production Chinese source read-only to my local machine and verified that the SHA-256 matched the production source digest saved by the program exactly.
Then I used the following from the production code:
extract_excerpt_source()
to regenerate the actual excerpt input sent to GLM.
The results were:
Original body:
8228 chars
10234 bytes
Cleaned body:
892 chars
2024 bytes
Full GLM payload:
3427 bytes
In other words, the actual content sent to GLM for this article was not long.
The current excerpt extraction logic itself allows for inputs far larger than this scale, so there is no evidence that the HTTP 400 was caused by the body being too long or the request body being too large.
What is truly quite specific is that, after cleaning out Gutenberg comments, HTML tags, and other content, the remaining body still continuously contained:
USDT
Arbitrum One
MEXC
OKX
Deposit
Withdrawal
On-chain network
Full address
Transfer amount
Transaction fee
Arrival record
This combination of content very likely triggered the model’s content moderation.
However, the existing evidence can only prove that:
GLM 1301 content filtering was the direct cause of this HTTP 400.
As to exactly which sentence, which address, or which category of words triggered it, the current evidence is insufficient to determine precisely.
4. I Do Not Intend to Modify Historical Articles to Pass the Model’s Review
After confirming it was model content filtering, there was actually another way to handle it.
I could have continuously modified the Chinese source:
Delete potentially sensitive words
→ Delete addresses
→ Simplify amount descriptions
→ Modify transfer steps
→ Request GLM again
→ Until the model accepts it
But I ultimately did not choose this direction.
The original goals of processing historical articles were:
Standardize historical formats
Fill in missing Chinese excerpts
Redo English translations
Not:
Modifying the original article content
To accommodate the current review rules of a specific model
This article in particular records a real historical operation process.
If I deleted networks, amounts, addresses, or operation steps for the sake of model review, it would ultimately destroy the historical record itself.
So, once I determined that the HTTP 400 was due to model content filtering, I felt that continuing to blindly call GLM was no longer meaningful.
A more reasonable approach was:
Preserve the automated failure facts
→ Stop automated retries
→ Switch to manual fallback
5. The ChatGPT Manual Processing Route Was Already Validated a Few Days Ago
This was not the first time I considered manual intervention.
When processing another abnormal historical article a few days ago, the automated workflow similarly could not complete smoothly, and I ultimately tried manual processing via ChatGPT.
The relevant process is recorded in:
A historical article processed manually a few days ago
That practice validated at least one thing:
When the automated workflow encounters a few articles it cannot push forward, there is no need to stall the entire batch.
That article can be individually moved to manual processing.
However, today article 7756 exposed a new boundary.
The previous manual completion mechanism primarily considered:
translation_failed
blocked
But 7756 stopped at:
excerpt_failed
That is:
This time, even the Chinese excerpt had not been generated successfully yet.
Therefore, the original manual completion entry point could not directly and safely cover this situation.
6. The Original mark-manual-completed Did Not Support excerpt_failed
The repository already had a command specifically for external manual completion:
python3 bin/history-migration.py mark-manual-completed \
--post-id 文章ID
The formal confirmation was:
python3 bin/history-migration.py mark-manual-completed \
--post-id 文章ID \
--confirmed
This design itself is well-suited for ChatGPT manual fallback.
The problem was that the original allowed states were primarily:
translation_failed
blocked
While the current article was:
excerpt_failed
These two situations cannot be simply equated.
If it was translation_failed, it usually meant:
Chinese excerpt was generated
→ Chinese excerpt was written
→ English override translation phase failed
But excerpt_failed meant:
The Chinese excerpt had not even been successfully generated
If I simply added:
excerpt_failed
to the allowed states without adding extra checks, the following could occur:
Chinese excerpt is still empty
→ English article originally had content
→ mark-manual-completed mistakenly assumes manual work is done
→ workflow_status = completed
This is obviously unsafe.
7. Adding Stricter Manual Completion Checks for excerpt_failed
Therefore, I made a very small but crucial extension to mark-manual-completed this time.
excerpt_failed can now enter the manual completion check, but it must simultaneously satisfy:
Chinese article ID is correct
Chinese article status = publish
Chinese post_excerpt is not empty
English article ID is correct
English article status = publish
English title is not empty
English content is not empty
Polylang Chinese-English relationship is bidirectionally correct
The key check that was truly added is:
Chinese excerpt is not empty
And this condition only applies to:
excerpt_failed
The original:
translation_failed
blocked
behavior was not unconditionally relaxed as a result.
8. The First Preview Correctly Prevented Manual Completion
After modifying the code and passing tests, I did not immediately start modifying WordPress.
I first ran a Preview directly using the current real article 7756:
cd ~/code/wordpress-ai-excerpt-backfill
python3 bin/history-migration.py mark-manual-completed \
--post-id 7756
At that time, the Chinese excerpt was still empty.
The program output:
Mode: preview
Article: zh=7756 en=10072
Current status: excerpt_failed
Read-only checks: post ID, publish, Polylang, English title and body (excerpt_failed additionally checks Chinese excerpt)
Allow manual completion: No
Write operations: No
Block reason: Chinese excerpt is empty
This result was exactly what I wanted to see.
It proved that the program did not mistakenly identify this article as “already manually processed” just because the English historical article originally had a title and body.
The Chinese excerpt had to be filled in first.
9. ChatGPT Manually Generates the Chinese Excerpt
Subsequently, I directly copied the article title and the full Gutenberg body from the WordPress editor and gave it to ChatGPT.
ChatGPT regenerated the Chinese excerpt based on the full original text:
This article records the actual process of transferring USDT from OKX to MEXC via the Arbitrum One network, including generating a deposit address on MEXC, selecting USDT and the corresponding withdrawal network on OKX, verifying the address and network, completing email and phone verification, checking the withdrawal status, and confirming the arrival through a small test transfer followed by subsequent transfers. The process also records platform risk warnings, transaction fees, and account balance changes, emphasizing that cross-platform transfers must use the same network for deposit and withdrawal, and that addresses must be carefully verified to avoid asset loss due to incorrect network or address selection.
Then I manually filled it into the excerpt field of the Chinese article in WordPress.

Here, the Chinese body was not modified to bypass moderation.
The only real addition was the previously missing post_excerpt.
10. ChatGPT Simultaneously Redoes the English Article
Since this article had already entered manual fallback, I ultimately did not let the automated translation pipeline continue handling the subsequent English override translation.
Instead, I had ChatGPT directly complete:
English title
English excerpt
Full English body
Image alt
Figure caption
The final English title was:
Transferring USDT from OKX to MEXC via Arbitrum: The Process
The body continued to preserve the original Gutenberg structure:
Paragraph order unchanged
Image blocks unchanged
Image IDs unchanged
Media URLs unchanged
Full addresses unchanged
Only the natural language content was retranslated.

With this, the actual content in the production environment met the requirements for manual completion.
However, at this point, I still did not manually modify the state JSON.
11. The Program Only Allowed Manual Completion After Re-running the Preview
After manually saving the Chinese excerpt and English content, I ran the same Preview again:
cd ~/code/wordpress-ai-excerpt-backfill
python3 bin/history-migration.py mark-manual-completed \
--post-id 7756
This time, the result changed to:
Mode: preview
Article: zh=7756 en=10072
Current status: excerpt_failed
Read-only checks: post ID, publish, Polylang, English title and body (excerpt_failed additionally checks Chinese excerpt)
Allow manual completion: Yes
Write operations: No
This meant the program had confirmed via a production read-only query that:
Chinese excerpt exists
Chinese article is normally published
English title exists
English body exists
English article is normally published
Polylang Chinese-English correspondence is normal
Only after the actual content in the production environment met the requirements was proceeding to the next step allowed.
This is much more reliable than directly modifying the local:
workflow_status = completed
It is far more reliable.
12. Finally Executing –confirmed
Preview confirmed:
Allow manual completion: Yes
After that, I formally executed:
cd ~/code/wordpress-ai-excerpt-backfill
python3 bin/history-migration.py mark-manual-completed \
--post-id 7756 \
--confirmed
The real output was:
Mode: confirmed
Article: zh=7756 en=10072
Current status: excerpt_failed
Read-only checks: post ID, publish, Polylang, English title and body (excerpt_failed additionally checks Chinese excerpt)
Allow manual completion: Yes
Write operations: Yes

It should be specifically noted that the following here:
Write operations: Yes
does not mean modifying WordPress again.
The content in WordPress had already been manually saved by me.
This command writes to the local coordination state.
It ultimately adds:
"manual_completion": {
"status": "confirmed",
"method": "manual_external"
}
And updates:
workflow_status
to:
completed
13. completed Does Not Disguise the Original Automated Failure as a Success
This time, I was particularly concerned about one issue:
Since it was later completed manually, what should happen to the original GLM failure evidence?
My choice was:
Do not modify it.
The final article status was:
workflow_status: completed
But the execution evidence still clearly records:
status: excerpt_generation_failed
The last automated failure is also preserved:
HTTP request failed with status 400
reason: http_client_error
At the same time, the following was added:
manual_completion:
method: manual_external
status: confirmed

completed, but the original excerpt_generation_failed, HTTP 400, and manual completion records are all preserved.I think this state is more factual than directly changing the execution evidence to:
success
What actually happened was:
Automated excerpt failure
+
Manual external completion
=
Final business goal achieved
These three things can absolutely coexist.
completed means:
The current historical article migration task is complete.
It does not mean:
The previous automated execution never failed.
14. The Entire Batch Ultimately Recovered to 20 / 20 completed
Finally, I rechecked the entire batch:
cd ~/code/wordpress-ai-excerpt-backfill
echo "========== FINAL RESULT =========="
python3 bin/history-migration.py summary \
| grep -E \
'mixed-syntaxhighlighter-20260814-03|最新未完成批次|建议创建下一批|建议:'
The final output:
mixed-syntaxhighlighter-20260814-03:
total=20
completed=20
remaining=0
Latest incomplete batch: None
Suggest creating next batch: True
Suggestion: all batches complete

completed=20, remaining=0 again, allowing the next batch to be created.This means:
One article being rejected by the model did not cause the entire historical article migration batch to be stuck indefinitely.
15. The SOP Now Has a Formal Manual Fallback Path
Under normal circumstances, the daily main workflow remains unchanged:
Create fixed batch
→ Manual check / Gutenberg normalization
→ mark-converted
→ Production read-only verification
→ run-ready --execute
→ completed
After a normal single-article failure occurs during the formal execution phase, it still prioritizes:
recover --post-id
→ Program determines recovery strategy
→ recover --execute
For example, the program can automatically determine based on production source, pre-write baseline, and execution evidence:
resume
restart_from_current
blocked
none
Manual processing from a few days ago already proved that:
A very small number of abnormal articles can be individually taken over by ChatGPT.
And today, article 7756 further formally integrated this route into the state machine.
Now, when encountering a similar deterministic model rejection, you can follow:
GLM excerpt continuous failure
→ recover / execution evidence confirms the real cause
→ Confirm it is a deterministic failure like model content filtering
→ Stop blind retries
→ ChatGPT generates Chinese excerpt
→ ChatGPT generates English title, excerpt, and full body
→ Manually save to WordPress
→ mark-manual-completed Preview
→ Production read-only checks
→ Confirm manual completion is allowed
→ mark-manual-completed --confirmed
→ workflow_status = completed
Throughout this process:
Do not delete state
Do not clear evidence
Do not manually fake completed
Do not modify original failure records
This path has also been incorporated into the currently primary WordPress historical article processing SOP.
When encountering similar problems in the future, there is no need to try to remember:
What command should be executed after manual translation is complete?
Does the JSON need to be modified?
How can this article be moved to completed?
Just run:
mark-manual-completed
and that’s it.
16. Why I Think This Addition Is Not Just a Command, But a State Design
As historical article automated processing progresses, the vast majority of ordinary articles have actually become increasingly stable.
What usually consumes time are the few exceptions.
For example, the ones actually encountered so far include:
SSH timeout
REST authentication exception
GLM TimeoutError
Protected Token validation failure
WordPress HTTP 500
Ctrl+C interruption
Execution evidence inconsistent with workflow
Model content filtering
If every time an exception occurs, it is resolved by:
Deleting state
Clearing evidence
Modifying JSON
Forcing completed
then as the project goes on longer, the local state will ultimately become increasingly untrustworthy.
I now prefer to maintain a rather clear principle:
If the automated process fails, save the automated failure.
If manual completion is done, record the manual completion.
The final workflow state only expresses whether the current task is complete.
This way, when reviewing a historical article later, it will still be possible to answer:
Why did it fail at that time?
Where did the automated workflow execute to?
What was the real error?
Was the production content modified afterwards?
Who ultimately completed it?
Did it pass production checks?
Why was it ultimately allowed to enter completed?
This is more valuable than just seeing:
completed
as the only result.
17. We Need to Continue Observing the Content Moderation Strictness of Different Large Models
This GLM 1301 incident also made me reconsider the choice of models during the historical article automation process.
For ordinary technical content, GLM’s automated excerpt generation and translation across a large volume of historical articles is currently working normally overall.
But this article was rather special.
It continuously involved:
Digital assets
Deposit
Withdrawal
On-chain addresses
Network selection
Amounts
Transaction fees
Account balances
Arrival records
Even if the original article itself merely records a normal operation process, it may still be intercepted by the model’s content moderation.
Going forward, I plan to continue practically testing the moderation strictness of different domestic large models on this type of article.
I will focus on observing several factors:
Chinese comprehension and generation quality
API stability
Invocation cost
Long-text capability
Structured output capability
False moderation interceptions
To see if there are domestic models with moderation strictness that is relatively more suitable for processing historical content on a technical blog.
From my current experience actually using different models, some overseas large models encounter fewer similar false interceptions when processing such normal technical records.
However, this observation cannot yet be simply generalized as:
Domestic models all strictly moderate
Overseas models do not moderate at all
Safety policies from different vendors, different models, and even different time periods can all change.
Therefore, continued verification through real API calls is still needed.
I also do not intend to chronically modify my historical articles to accommodate the content moderation rules of a specific model.
I prefer that the subsequent workflow continues to develop in this direction:
Model A completes normally
→ completed
Model A temporary failure
→ Limited retries
Model A deterministic rejection
→ Stop meaningless retries
→ Try Model B
Model B still cannot process
→ ChatGPT / manual fallback
→ Production acceptance
→ manual completion
→ completed
If such cases continue to appear in the future, the next phase could even consider evolving the current:
Manual ChatGPT fallback
further into:
Multi-model automated fallback
This would compress manual intervention down to the very few articles that truly require human judgment.
Summary
Today started out as just a very ordinary batch processing exception.
Out of the 20 articles:
19 completed normally
1 failed during Chinese excerpt generation
Initially, all I saw was:
HTTP 400
After further inspection, it was finally confirmed:
HTTP 400
→ GLM error.code = 1301
→ contentFilter
→ Content safety filtering
Subsequently, through the real Chinese source and the production excerpt extraction logic, it was confirmed that:
cleaned_content = 892 chars
payload = 3427 bytes
There was no evidence that the problem stemmed from input length.
Once it was determined that repeatedly requesting GLM was no longer meaningful, I did not choose to modify the historical body to accommodate the model. Instead, I switched to:
ChatGPT generates Chinese excerpt
→ ChatGPT completes English title, excerpt, and body
→ Manually save to WordPress
At the same time, the original:
mark-manual-completed
had excerpt_failed safety support added.
If an article stops at:
excerpt_failed
the program must now additionally confirm:
Chinese excerpt is not empty
and simultaneously check:
post ID
publish
English title
English body
Polylang
Only after truly passing the production read-only checks is it allowed to:
python3 bin/history-migration.py mark-manual-completed \
--post-id 文章ID \
--confirmed
The final article simultaneously preserves:
execution_evidence = excerpt_generation_failed
last_failure = HTTP 400
manual_completion = manual_external
workflow_status = completed
The entire batch ultimately recovered to:
total=20
completed=20
remaining=0
Latest incomplete batch: None
Suggest creating next batch: True
Suggestion: all batches complete
So what was truly solved this time is no longer just:
“What to do when an article gets an HTTP 400?”
It further answered another, more important question:
When an automated model explicitly refuses to process an article, how can the entire automated workflow continue to safely complete the article without tampering with historical evidence, modifying the original text to accommodate the model, or manually faking the state.
The current answer is:
The automated model can fail, but the entire historical article migration workflow must preserve a manual fallback path that is verifiable, auditable, and able to safely converge to completed.

