fix(skills): debug infrastructure + disconnect credential cleanup

[senamakel]

Summary

• Skills debug test suite — Rust integration tests (skills_debug_e2e.rs, skills_rpc_e2e.rs, skills_notion_live.rs) that exercise the full skill lifecycle: discover → start → tools → call → setup → tick → session → disconnect → stop
• Debug shell scripts (scripts/debug-skill.sh, scripts/debug-notion-live.sh) that load env from .env via load-dotenv.sh for easy local testing
• Fix: disconnect flow now revokes OAuth credentials — disconnectSkill() was only stopping the skill and resetting setup_complete, leaving oauth_credential.json on disk. On restart the stale credential would be restored. Now sends oauth/revoked RPC before stopping so the event loop deletes the credential file and clears memory.

What was wrong

1. Frontend disconnectSkill() called stop + setSetupComplete(false) but never sent oauth/revoked
2. The OAuth credential file persisted on disk after disconnect
3. On next skill start, the old (possibly expired) credential was restored from disk
4. This caused confusing auth state: connection_status: "error", auth_status: "not_authenticated" even though setup_complete was false

Test plan

• cargo test --test skills_debug_e2e -- --nocapture — full lifecycle (5 tests)
• cargo test --test skills_rpc_e2e -- --nocapture — HTTP JSON-RPC stack
• cargo test --test skills_notion_live -- --nocapture — live Notion with real OAuth proxy
• skill_disconnect_flow test verifies credential cleanup
• npx tsc --noEmit in app/ — clean typecheck
• cargo fmt + prettier pass

🤖 Generated with Claude Code

Summary by CodeRabbit

• New Features

  • Skills can now be cleanly revoked/disabled so OAuth credentials are removed during disconnect.

• Tests

  • Added end-to-end integration suites covering skill lifecycle, RPC flows, and live backend interactions.

• Chores

  • New debug utilities for skill development and live testing.
  • Added optional JWT_TOKEN env config to support JWT-based auth in debug flows.

[coderabbitai]

Caution

Review failed

Pull request was closed or merged during review

📝 Walkthrough

Walkthrough

Adds optional JWT env var for debug flows, implements OAuth revocation and persisted-credential cleanup on skill disconnect, introduces RPC/write helpers, adds two debug scripts, and adds multiple end-to-end integration tests for engine lifecycle, RPC, and live Notion scenarios.

Changes

Cohort / File(s)	Summary
Config ./.env.example	Added optional JWT_TOKEN= entry for JWT-based debug and proxy requests.
Skill manager app/src/lib/skills/manager.ts	disconnectSkill now attempts OAuth revocation via RPC, stops the skill, and falls back to host-side persisted credential deletion if revocation fails; retains setup-complete reset and state sync.
Skills API app/src/lib/skills/skillsApi.ts	Added RPC/write helpers: revokeOAuth(skillId, integrationId), removePersistedOAuthCredential(skillId), and disableSkill(skillId) (new exports).
Debug scripts scripts/debug-skill.sh, scripts/debug-notion-live.sh	New bash scripts: generic skill E2E debug runner and a Notion live debug flow that validates BACKEND_URL, JWT_TOKEN, optional CREDENTIAL_ID, exercises backend/proxy, and runs cargo tests.
E2E tests — engine/debug tests/skills_debug_e2e.rs	New comprehensive engine E2E tests covering discovery, start/stop, tool calls, setup flows, ticks, session RPCs, rapid start/stop, and disconnect behavior including oauth_credential.json handling.
E2E tests — live Notion tests/skills_notion_live.rs	New gated live Notion integration test that uses BACKEND_URL/JWT_TOKEN/CREDENTIAL_ID and real skill data to exercise startup and several tool calls with timeouts.
E2E tests — RPC tests/skills_rpc_e2e.rs	New HTTP JSON-RPC E2E test that spins up the RPC server and drives discovery, start, tool calls, sync/status/stop and list flows over HTTP.

Sequence Diagram(s)

sequenceDiagram
  participant Manager as "SkillManager" rect rgba(135,206,235,0.5)
  participant Backend as "Backend RPC" rect rgba(144,238,144,0.5)
  participant Skill as "Skill Runtime" rect rgba(255,182,193,0.5)
  participant Engine as "Engine Registry / Tools Sync" rect rgba(255,223,186,0.5)

  Manager->>Backend: revokeOAuth(skillId, credentialId)
  Backend-->>Manager: success / error (logged)
  alt revocation succeeded
    Manager->>Skill: stopSkill(skillId)
  else revocation failed
    Manager->>Skill: stopSkill(skillId)
    Manager->>Backend: removePersistedOAuthCredential(skillId)
    Backend-->>Manager: ack / error (logged)
  end
  Skill-->>Manager: stopped
  Manager->>Backend: rpcSetSetupComplete(skillId, false)
  Backend-->>Manager: ack
  Manager->>Engine: emitStateChange(skillId)
  Engine->>Backend: syncTools(skillId)
  Backend-->>Engine: ack

Loading

Estimated code review effort

🎯 4 (Complex) | ⏱️ ~45 minutes

Poem

🐇 I found a token snug and neat,

nudged scripts awake with a tiny tweet.
I told the skill to say goodbye, revoke its key,
then hopped through tests and danced with glee.
A rabbit's nod — all flows agree.

🚥 Pre-merge checks | ✅ 3

✅ Passed checks (3 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly summarizes the main changes: adding debug infrastructure and fixing the disconnect credential cleanup flow, both of which are central to this PR's objectives.
Docstring Coverage	✅ Passed	Docstring coverage is 80.77% which is sufficient. The required threshold is 80.00%.

_{✏️ Tip: You can configure your own custom pre-merge checks in the settings.}

✨ Finishing Touches

📝 Generate docstrings

• Create stacked PR
• Commit on current branch

🧪 Generate unit tests (beta)

• Create PR with unit tests
• Commit unit tests in branch fix/skills-again

---

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[coderabbitai]

Actionable comments posted: 7

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@app/src/lib/skills/manager.ts`:
- Around line 345-350: When rpcRevokeOAuth(skillId) fails in disconnectSkill,
add a host-side fallback to remove the persisted OAuth credential so stale
oauth_credential.json isn't restored on next start: inside async
disconnectSkill(skillId: string) catch block for rpcRevokeOAuth, detect the
"runtime already stopped" case (or any failure) and call a new helper like
removePersistedOAuthCredential(skillId) (or invoke existing cleanup path) to
delete the host-stored credential for that skill, then log success/failure; keep
the existing behavior of continuing disconnect flow after the fallback.

In `@app/src/lib/skills/skillsApi.ts`:
- Around line 121-129: The helper revokeOAuth currently fabricates the string
"default" when integrationId is omitted, causing the Rust oauth/revoked handler
to clear the wrong memory bucket; change revokeOAuth (and any callers like
disconnectSkill) to require and pass the actual stored credentialId instead of
defaulting—i.e., make revokeOAuth accept a non-optional integrationId (remove
the ?), or if you intend "clear all" semantics, call callCoreRpc without an
integrationId param (or pass null/omit params.integrationId) so the backend can
treat an omitted ID as “clear all”; update calls to revokeOAuth to provide the
real credentialId and ensure callCoreRpc sends params.integrationId only when
present.

In `@scripts/debug-notion-live.sh`:
- Around line 119-126: The pipelines using "cargo test ... | grep -E ... | head"
can cause the script to exit under set -euo pipefail when grep returns non-zero;
to fix, run the cargo test command and capture its exit code and full output
(e.g., via a temporary file or using "tee" into a variable), then run grep/head
against that captured output as a best-effort filter; specifically update the
two invocations of "cargo test --test skills_debug_e2e ..." and "cargo test
--test skills_notion_live ..." so you preserve the original cargo exit status
(inspect ${PIPESTATUS[0]} or use the captured file) and only fail the script
based on the cargo test exit code while allowing grep/head to be non-fatal.

In `@tests/skills_debug_e2e.rs`:
- Around line 665-671: The test currently only logs whether
oauth_credential.json was deleted (using cred_path.exists()) so a cleanup
regression won't fail CI; replace the conditional logging with a hard assertion
that the credential file was removed (e.g., assert!(!cred_path.exists(), "..."))
so the test fails if oauth_credential.json still exists after the oauth/revoked
flow. Update the assertion message to mention "oauth_credential.json deleted
after oauth/revoked" and keep the cred_path identifier to locate the check in
tests/skills_debug_e2e.rs.

In `@tests/skills_notion_live.rs`:
- Around line 72-90: The test currently prints sensitive auth material (partial
JWT via jwt_token.get(..20) and the full oauth_credential.json read via
std::fs::read_to_string(&cred_path)), so change the logging to avoid dumping
secrets: stop printing the JWT substring and instead log a redacted placeholder
(e.g., "<redacted>" or the JWT length), and for cred_path/real_data_dir only log
whether the file exists and optionally non-sensitive metadata (e.g., file size
or "contains credentials" flag) rather than the raw contents; update the
eprintln calls around jwt_token, cred_path, and the std::fs::read_to_string
usage to implement this redaction.
- Around line 51-70: The test notion_live_with_real_data should be made
explicitly opt-in: either add #[ignore] to the test or gate its execution behind
a dedicated environment flag (e.g. RUN_LIVE_NOTION) and exit early if it's not
set; remove silent fallbacks for backend_url, jwt_token, credential_id and
real_data_dir (currently using env_or with defaults) and instead error/fail the
test when those env vars are missing so callers must provide BACKEND_URL,
JWT_TOKEN, CREDENTIAL_ID and SKILLS_DATA_DIR; reference the
notion_live_with_real_data test and the env_or uses for backend_url, jwt_token,
credential_id and real_data_dir to locate and change the logic.

In `@tests/skills_rpc_e2e.rs`:
- Around line 102-108: The helper function check_result should fail-fast on
protocol errors rather than returning a sentinel; modify check_result to panic
(e.g., using panic! or unwrap-like behavior) when resp contains an "error" so
tests like skills_start, skills_list_tools, skills_call_tool, skills_sync,
skills_status, and skills_stop will fail immediately on JSON-RPC protocol
regressions; keep any expected-error behavior confined to the specific test call
sites by asserting for errors there instead of relying on check_result to
translate them into a sentinel, and otherwise return the "result" value as
before.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: dbc1c99a-ebbb-4d41-b06d-9d9b9242ad8d

📥 Commits

Reviewing files that changed from the base of the PR and between a193240 and f088cdf.

📒 Files selected for processing (8)

• .env.example
• app/src/lib/skills/manager.ts
• app/src/lib/skills/skillsApi.ts
• scripts/debug-notion-live.sh
• scripts/debug-skill.sh
• tests/skills_debug_e2e.rs
• tests/skills_notion_live.rs
• tests/skills_rpc_e2e.rs

[coderabbitai]

Actionable comments posted: 2

♻️ Duplicate comments (3)

tests/skills_notion_live.rs (2)

64-83: ⚠️ Potential issue | 🟠 Major

Gate this live test behind an explicit opt-in.

Defaulting to a staging backend, a concrete CREDENTIAL_ID, and ~/.openhuman/skills_data means a plain run can hit real services and read or mutate a developer's Notion state. Mark this ignored or gate it behind a dedicated env flag, and require the live inputs instead of silently falling back to real defaults.

One way to make the test opt-in

-#[tokio::test]
+#[tokio::test]
+#[ignore = "live test; set RUN_LIVE_NOTION=1 and required env vars to run"]
 async fn notion_live_with_real_data() {
@@
-    let backend_url = env_or("BACKEND_URL", "https://staging-api.alphahuman.xyz");
-    let jwt_token = env_or("JWT_TOKEN", "");
-    let credential_id = env_or("CREDENTIAL_ID", "69cafd0b103bd070232d3223");
+    if std::env::var("RUN_LIVE_NOTION").ok().as_deref() != Some("1") {
+        eprintln!("SKIPPED: set RUN_LIVE_NOTION=1 to run the live Notion test");
+        return;
+    }
+
+    let backend_url = std::env::var("BACKEND_URL").expect("BACKEND_URL is required");
+    let jwt_token = std::env::var("JWT_TOKEN").expect("JWT_TOKEN is required");
+    let credential_id = std::env::var("CREDENTIAL_ID").expect("CREDENTIAL_ID is required");
@@
-    let real_data_dir = PathBuf::from(env_or(
-        "SKILLS_DATA_DIR",
-        &dirs::home_dir()
-            .unwrap()
-            .join(".openhuman/skills_data")
-            .to_string_lossy(),
-    ));
+    let real_data_dir =
+        PathBuf::from(std::env::var("SKILLS_DATA_DIR").expect("SKILLS_DATA_DIR is required"));

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/skills_notion_live.rs` around lines 64 - 83, The test function
notion_live_with_real_data currently uses real defaults (backend_url, jwt_token,
credential_id, skills_dir, real_data_dir) and must be made explicit opt-in: wrap
the test with an opt-in check (e.g., require an environment flag like
RUN_LIVE_NOTION_TEST or annotate the test #[ignore] and only run when the flag
is set), and fail early with a clear message if the flag is not present; also
remove silent fallbacks for jwt_token, credential_id and SKILLS_DATA_DIR so the
test requires those envs to be explicitly provided before contacting real
services.

---

89-103: ⚠️ Potential issue | 🟠 Major

Redact live auth and workspace data from the logs.

This currently prints part of the JWT, raw oauth_credential.json, backend/proxy bodies, auth-related state, and tool output from a real Notion workspace. With --nocapture, that is easy to leak into terminals, CI artifacts, or pasted issues; log only presence, counts, and redacted metadata. Based on learnings "Never log secrets, raw JWTs, API keys, credentials, or full PII in debug output".

Also applies to: 125-166, 186-196, 214-240, 259-289, 299-310

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/skills_notion_live.rs` around lines 89 - 103, The test logs currently
print sensitive data (partial JWT via jwt_token, raw oauth_credential.json read
at cred_path, backend_url, credential_id, and other auth/tool outputs); change
the prints in tests/skills_notion_live.rs (where jwt_token, cred_path,
backend_url, credential_id, skills_dir, real_data_dir are used) to avoid
emitting secrets by: trim or mask jwt_token (e.g., show only length or
"redacted"), never print file contents from cred_path—log only existence and
size/counts (e.g., "oauth_credential.json present, N bytes" or "missing"), and
replace any backend/proxy/auth/tool output prints with redacted summaries
(presence, counts, and non-sensitive metadata). Apply the same redaction pattern
to the other highlighted ranges (125-166, 186-196, 214-240, 259-289, 299-310).

tests/skills_rpc_e2e.rs (1)

114-120: ⚠️ Potential issue | 🟠 Major

Fail fast on unexpected JSON-RPC errors.

check_result() turns protocol failures into a sentinel object, and most call sites only print it. That lets regressions in skills_start, skills_list_tools, skills_call_tool, skills_sync, skills_status, and skills_stop slip through with a green test.

Suggested tightening

 fn check_result(resp: &Value, context: &str) -> Value {
     if let Some(err) = resp.get("error") {
-        eprintln!("  [JSONRPC ERROR] {context}: {err}");
-        // Don't panic — some errors are expected
-        return json!({"__error": err.clone()});
+        panic!("  [JSONRPC ERROR] {context}: {err}");
     }
     resp.get("result").cloned().unwrap_or(json!(null))
 }

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/skills_rpc_e2e.rs` around lines 114 - 120, check_result currently
converts any JSON-RPC "error" into a sentinel {"__error": ...} which lets
regressions pass; change check_result to fail fast by panicking (or using
assert!) when resp.get("error") is Some, including the context and error details
in the panic message, and otherwise return the
resp.get("result").cloned().unwrap_or(json!(null)); update call sites in
skills_start, skills_list_tools, skills_call_tool, skills_sync, skills_status,
and skills_stop to rely on this failing behavior (no sentinel handling) so
unexpected protocol errors cause test failures immediately.

🤖 Prompt for all review comments with AI agents

Verify each finding against the current code and only fix it if needed.

Inline comments:
In `@tests/skills_notion_live.rs`:
- Line 128: The current debug prints use byte-indexed slicing like
&body[..body.len().min(N)] which can panic on UTF-8 boundaries; add a small
UTF-8-safe helper (e.g., fn truncate_chars(s: &str, max_chars: usize) -> &str or
String named truncate_chars) and replace all occurrences of byte-slicing in
tests/skills_notion_live.rs (the eprintln! calls that print Body and similar
debug strings) with calls to that helper to produce character-truncated output;
ensure the helper returns a &str or String truncated to at most max_chars
characters without splitting multibyte characters and use it in the five places
mentioned.

In `@tests/skills_rpc_e2e.rs`:
- Around line 182-303: Replace the informal eprintln! checks after each
lifecycle RPC with strict assertions so the test fails on unexpected state: for
the calls using rpc_call and check_result (notably "openhuman.skills_discover",
"openhuman.skills_start", "openhuman.skills_list_tools",
"openhuman.skills_call_tool", "openhuman.skills_sync",
"openhuman.skills_status", "openhuman.skills_stop", "openhuman.skills_list")
assert that results are the expected types and values — e.g., discover returns a
non-empty array, skills_start returns no "__error" and status == "running" (or
expected status), skills_list_tools returns a non-empty "tools" array and at
least one tool has a "name", skills_call_tool result contains no "__error" and a
useful payload, skills_sync returns a success/ack, skills_status exposes the
published "state" keys and expected status, skills_stop returns success and
subsequently skills_list (post-stop) reflects the stopped/removed skill (count
decreased or skill_id absent); locate these checks around rpc_call(...) and
check_result(...) invocations and replace or augment the eprintln! validations
with proper assert! / assert_eq! / assert_ne! calls referencing skill_id,
tool_name, and the Value fields accessed via get(...).

---

Duplicate comments:
In `@tests/skills_notion_live.rs`:
- Around line 64-83: The test function notion_live_with_real_data currently uses
real defaults (backend_url, jwt_token, credential_id, skills_dir, real_data_dir)
and must be made explicit opt-in: wrap the test with an opt-in check (e.g.,
require an environment flag like RUN_LIVE_NOTION_TEST or annotate the test
#[ignore] and only run when the flag is set), and fail early with a clear
message if the flag is not present; also remove silent fallbacks for jwt_token,
credential_id and SKILLS_DATA_DIR so the test requires those envs to be
explicitly provided before contacting real services.
- Around line 89-103: The test logs currently print sensitive data (partial JWT
via jwt_token, raw oauth_credential.json read at cred_path, backend_url,
credential_id, and other auth/tool outputs); change the prints in
tests/skills_notion_live.rs (where jwt_token, cred_path, backend_url,
credential_id, skills_dir, real_data_dir are used) to avoid emitting secrets by:
trim or mask jwt_token (e.g., show only length or "redacted"), never print file
contents from cred_path—log only existence and size/counts (e.g.,
"oauth_credential.json present, N bytes" or "missing"), and replace any
backend/proxy/auth/tool output prints with redacted summaries (presence, counts,
and non-sensitive metadata). Apply the same redaction pattern to the other
highlighted ranges (125-166, 186-196, 214-240, 259-289, 299-310).

In `@tests/skills_rpc_e2e.rs`:
- Around line 114-120: check_result currently converts any JSON-RPC "error" into
a sentinel {"__error": ...} which lets regressions pass; change check_result to
fail fast by panicking (or using assert!) when resp.get("error") is Some,
including the context and error details in the panic message, and otherwise
return the resp.get("result").cloned().unwrap_or(json!(null)); update call sites
in skills_start, skills_list_tools, skills_call_tool, skills_sync,
skills_status, and skills_stop to rely on this failing behavior (no sentinel
handling) so unexpected protocol errors cause test failures immediately.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: defaults

Review profile: CHILL

Plan: Pro

Run ID: aa0c3e7b-ac2a-4aae-a67e-67094b62e243

📥 Commits

Reviewing files that changed from the base of the PR and between f088cdf and d6532f1.

📒 Files selected for processing (3)

• tests/skills_debug_e2e.rs
• tests/skills_notion_live.rs
• tests/skills_rpc_e2e.rs

✅ Files skipped from review due to trivial changes (1)

• tests/skills_debug_e2e.rs

[coderabbitai]

⚠️ Potential issue | 🟠 Major

🧩 Analysis chain

🏁 Script executed:

# First, check if the file exists and get its line count
wc -l tests/skills_notion_live.rs

# Read the file and check the specific lines mentioned
cat -n tests/skills_notion_live.rs | sed -n '120,130p'
cat -n tests/skills_notion_live.rs | sed -n '155,170p'
cat -n tests/skills_notion_live.rs | sed -n '260,270p'
cat -n tests/skills_notion_live.rs | sed -n '285,295p'

Repository: tinyhumansai/openhuman

Length of output: 2434

---

🏁 Script executed:

# Search for similar byte-slicing patterns in the file
rg '\[\.\..*\.len\(\)\.min\(' tests/skills_notion_live.rs -n

Repository: tinyhumansai/openhuman

Length of output: 450

---

🏁 Script executed:

# Create a test to validate the proposed solution logic
cat > /tmp/test_truncate.rs << 'EOF'
fn truncate_for_log(s: &str, max_chars: usize) -> String {
    let truncated: String = s.chars().take(max_chars).collect();
    if truncated.len() == s.len() {
        truncated
    } else {
        format!("{truncated}...")
    }
}

fn main() {
    // Test 1: ASCII string longer than limit
    let ascii = "Hello World This is a Test";
    println!("Test 1: {}", truncate_for_log(ascii, 5));
    
    // Test 2: Multi-byte UTF-8 at boundary
    let multibyte = "Hello 世界世界世界世界"; // Mix of ASCII and 3-byte chars
    println!("Test 2: {}", truncate_for_log(multibyte, 8));
    
    // Test 3: String shorter than limit
    let short = "Hi";
    println!("Test 3: {}", truncate_for_log(short, 10));
    
    // Test 4: Emoji test
    let emoji = "Test 🎉🎉🎉🎉🎉";
    println!("Test 4: {}", truncate_for_log(emoji, 6));
}
EOF

# Check if Rust is available to compile
rustc --version 2>/dev/null || echo "Rust not available in sandbox"

# But we can verify the logic conceptually with Python
python3 << 'PYEOF'
def truncate_for_log(s: str, max_chars: int) -> str:
    truncated = s[:max_chars]
    if len(truncated) == len(s):
        return truncated
    else:
        return truncated + "..."

# Test cases
test_cases = [
    ("Hello World This is a Test", 5),
    ("Hello 世界世界世界世界", 8),
    ("Hi", 10),
    ("Test 🎉🎉🎉🎉🎉", 6),
]

print("Truncate function test results:")
for text, limit in test_cases:
    result = truncate_for_log(text, limit)
    print(f"  Input: {text!r}, limit={limit}")
    print(f"  Output: {result!r}")
    print()
PYEOF

Repository: tinyhumansai/openhuman

Length of output: 356

---

Truncate log strings on character boundaries instead of byte indices.

The byte-indexed slicing pattern &string[..string.len().min(N)] can panic on valid UTF-8 when the cutoff lands in the middle of a multibyte character. This is realistic for Notion API responses and user-generated content.

Replace all five occurrences (lines 128, 161, 165, 265, 289) with a character-based truncation helper:

UTF-8-safe truncation helper

+fn truncate_for_log(s: &str, max_chars: usize) -> String {
+    let truncated: String = s.chars().take(max_chars).collect();
+    if truncated.len() == s.len() {
+        truncated
+    } else {
+        format!("{truncated}...")
+    }
+}
+
@@
-                eprintln!("  Body: {}...", &body[..body.len().min(200)]);
+                eprintln!("  Body: {}", truncate_for_log(&body, 200));
@@
-                eprintln!("  Body: {}...", &body[..body.len().min(300)]);
+                eprintln!("  Body: {}", truncate_for_log(&body, 300));
@@
-                    "  ✗ Proxy returned {status}: {}...",
-                    &body[..body.len().min(200)]
+                    "  ✗ Proxy returned {status}: {}",
+                    truncate_for_log(&body, 200)
                 );
@@
-                        eprintln!("  Result: {}...", &text[..text.len().min(500)]);
+                        eprintln!("  Result: {}", truncate_for_log(text, 500));
@@
-                        eprintln!("  Result: {}...", &text[..text.len().min(500)]);
+                        eprintln!("  Result: {}", truncate_for_log(text, 500));

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@tests/skills_notion_live.rs` at line 128, The current debug prints use
byte-indexed slicing like &body[..body.len().min(N)] which can panic on UTF-8
boundaries; add a small UTF-8-safe helper (e.g., fn truncate_chars(s: &str,
max_chars: usize) -> &str or String named truncate_chars) and replace all
occurrences of byte-slicing in tests/skills_notion_live.rs (the eprintln! calls
that print Body and similar debug strings) with calls to that helper to produce
character-truncated output; ensure the helper returns a &str or String truncated
to at most max_chars characters without splitting multibyte characters and use
it in the five places mentioned.