fix: address PR #19 review findings on argument ownership and UI errors

source_search.c: when a literal pattern containing whitespace is rewritten
into a word-order regex ("foo bar" -> "foo.*bar"), the replacement buffer
was allocated with raw malloc() but later released with
cbm_operation_arg_free() on every cleanup path, which charges the
operation-argument class for memory it never accounted and trips the
ownership check when memory phases are enabled. Allocate it with
cbm_alloc(CBM_MEM_CLASS_OPERATION_ARG, ...) so the pattern keeps one
allocation class whichever branch produced it. The raw site count for
source_search.c drops from 64 to 63 in scripts/memory-core-baseline.txt.

project_arg.c: the sanitized-name, normalized-path and cache-tail branches
freed the caller's project string before checking whether the replacement
copy was allocated. On allocation failure they returned NULL, and callers
then reported "project is required" for a request that did supply one.
Each branch now keeps the original project when its copy fails and frees
it only after the replacement exists.

graph-ui native.ts: fetchRead parsed the body as JSON before checking the
status, so a non-JSON error body (the server's plain-text 404, a proxy
error page) surfaced as a JSON SyntaxError instead of "HTTP <status>".
Check res.ok first and parse the error body defensively.

Author: ngallodev

graph-ui/src/api/native.ts

@@ -6,9 +6,10 @@ export async function fetchRead<T>(
   const query = new URLSearchParams();
   for (const [key, value] of Object.entries(args)) query.set(key, String(value));
   const res = await fetch(`/api/${endpoint}?${query}`);
-  const json = await res.json();
   if (!res.ok) {
-    throw new Error(json.error ?? `HTTP ${res.status}: ${res.statusText}`);
+    // Error bodies are not always JSON (plain-text 404, proxy error pages).
+    const body = (await res.json().catch(() => null)) as { error?: string } | null;
+    throw new Error(body?.error ?? `HTTP ${res.status}: ${res.statusText}`);
   }
-  return json as T;
+  return (await res.json()) as T;
 }

scripts/memory-core-baseline.txt

@@ -70,7 +70,7 @@ src/operations/schema.c	3
 src/operations/search.c	5
 src/operations/session_state.c	12
 src/operations/snippet.c	12
-src/operations/source_search.c	64
+src/operations/source_search.c	63
 src/operations/store_host.c	11
 src/operations/trace.c	5
 src/pipeline/artifact.c	38

src/operations/project_arg.c

@@ -33,8 +33,10 @@ static char *project_arg_normalize(char *project) {
         bool usable = encoded && strcmp(encoded, "root") != 0 && cbm_validate_project_name(encoded);
         if (usable) {
             char *copy = project_arg_strdup(encoded);
-            cbm_free(CBM_MEM_CLASS_OPERATION_ARG, project);
             free(encoded);
+            if (!copy)
+                return project; /* keep the supplied project on allocation failure */
+            cbm_free(CBM_MEM_CLASS_OPERATION_ARG, project);
             return copy;
         }
         free(encoded);
@@ -54,6 +56,8 @@ static char *project_arg_normalize(char *project) {
     if (normalized) {
         char *copy = project_arg_strdup(normalized);
         free(normalized);
+        if (!copy)
+            return project; /* keep the supplied project on allocation failure */
         cbm_free(CBM_MEM_CLASS_OPERATION_ARG, project);
         return copy;
     }
@@ -101,8 +105,11 @@ static char *project_arg_resolve_tail(char *project) {
     }
     cbm_closedir(dir);
     if (matches == 1) {
+        char *copy = project_arg_strdup(match);
+        if (!copy)
+            return project; /* keep the supplied project on allocation failure */
         cbm_free(CBM_MEM_CLASS_OPERATION_ARG, project);
-        return project_arg_strdup(match);
+        return copy;
     }
     return project;
 }

src/operations/source_search.c

@@ -2088,7 +2088,8 @@ cbm_operation_result_t cbm_source_search_operation_execute(const char *args,
     if (!use_regex && strchr(pattern, ' ')) {
         size_t plen = strlen(pattern);
         /* Worst case: every char is a space → ".*" between each char */
-        char *regex_pat = malloc(plen * 3 + 1);
+        /* Same class as the pattern it replaces: released via cbm_operation_arg_free(). */
+        char *regex_pat = cbm_alloc(CBM_MEM_CLASS_OPERATION_ARG, plen * 3 + 1);
         if (regex_pat) {
             char *dst = regex_pat;
             const char *src = pattern;