CalvinBackup/gstack

0 Fork 0

mirror of https://github.com/garrytan/gstack.git synced 2026-10-31 22:14:25 +01:00

Files

T

f67c478f05 v1.91.34.0 fix: /autoplan on current Claude Code and long sessions, quieter pre-push and sync guards, gstack-post, gstack-doctor (#3069 )

* docs: Oct 7 follow-up wave plan (pre-review)

* docs: Oct 7 follow-up wave plan, reviewed through /autoplan

* docs: Oct 7 wave plan, record final gate decisions (UC1 accepted, UC2 rejected)

* docs: credit #1822 to @Mike-E-Log and #1743 to @habassa5 (v1.64.0.0)

The v1.64.0.0 CHANGELOG entry credited the extension token fix (#1822)
and the polyfill exited promise (#1743) to the wrong handle, and the
extension-sender-auth test header repeated the first slip. Commit history
is not rewritten.

Fixes #3054.

Co-authored-by: Mike Ilog <48659643+Mike-E-Log@users.noreply.github.com>
Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(context-restore): offer newer checkpoints from nested repos and task worktrees

/context-restore could present an older checkpoint as the latest with no
error in two layouts:

1. A session started in a non-git parent saved from a nested repo, so the
   checkpoint went to the nested repo's bucket. Restore in the parent now
   lists checkpoints of other buckets whose project_root lies below the cwd
   (BELOW_CWD; the 200 newest are read, and from $HOME only each project's
   newest). /context-save also leaves a JSON pointer (checkpoint path, bucket,
   project_root) in the starting directory's bucket when $CLAUDE_PROJECT_DIR
   is set and files elsewhere; restore lists those as POINTER, in or out of git.
2. A plan checkpoint on the main tree's branch shadowed a newer checkpoint
   saved in a ticket worktree. When another branch holds a newer checkpoint
   for the same task (a worktree below the main tree, read from the new
   worktree: stamp; equal normalized titles; or a shared #123 / ABC-123
   token in titles or branch names), restore prints NEWER_TASK and the skill
   shows both and proposes the newer one. Generic titles (wip, checkpoint,
   save, notes, todo) never match on title alone, and the worktree rule
   applies only when restoring from the main tree, so sibling worktrees
   still never shadow each other.

The branch-first ordering itself is unchanged.

Refs #3065.

Co-authored-by: Thomas Gernhardt <t.gernhardt@softwareprojekt.net>
Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(redact-prepush): list each MEDIUM finding with rule, file line and fix

The pre-push hook printed only a MEDIUM count, which nobody could review
without re-running the engine by hand. It now prints one line per finding:
rule id, file and file line, and a fix, never the matched value.

Line numbers come from the hunk headers (combined --cc headers included), so
a finding in a later hunk or past a scan-chunk boundary points at the real
file line. Findings from the per-commit catch-up path name the commit whose
file line it is, so content removed before the pushed tip is still locatable.

Plan items: CEO-7 (summary half), DX-9 (fix lines), ENG-8 (line mapping).

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(redact-prepush): stop flagging your own email and already-public authors (#3060)

The hook never passed the engine's selfEmail / repoPublicEmails, so every
push that added the pusher's address, or a commit author's, raised a MEDIUM
pii.email warning for an address the destination already shows.

The hook now reads `git config user.email` and one bounded `git log` of
author and committer addresses, raw and mailmapped (%ae %aE %ce %cE): the
history of every pushed tip (those commits become public with the push),
each remote tip being replaced, and, for a new branch or an unknown remote
tip pushed to a configured remote, that remote's own tracking refs. A URL or
unknown destination never borrows tracking refs, and another remote's
history never counts.

The read stops at 50,000 commits (the newest authors are used) and 5 seconds.
An error or the timeout passes no history and, when an email finding is
listed, prints one line saying suppression was limited for this push. The two
inputs fail independently. HIGH findings and every other rule are untouched.

Controls: a stranger's address, an address only another remote knows, a URL
push next to a matching remote, and a first push of a repo with no history
all still report.

Plan items: A3, CEO-7, CEO-23 (A3 half), DX-9 (partial history), ENG-8
(history scope, mailmap).

Co-authored-by: akmandhania <143462686+akmandhania@users.noreply.github.com>
Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* feat(redact-prepush): per-address allowlist for pii.email (gstack.redact.allowEmail)

`git config --add gstack.redact.allowEmail <address>` allows that address for
MEDIUM pii.email findings only, so a team alias or support address that has
to be in the repo stops warning without reaching for --no-verify. It never
affects HIGH findings or any other rule, and the pii.email fix line names it.

Controls: a different address still reports, and a HIGH secret next to an
allowed address still blocks.

Plan item: DX-17.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* docs(troubleshooting): pre-push pii.email findings, exemptions and allowlist

Plan item: DX-12 (pre-push touchpoint).

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* test(redact-prepush): assemble fixture addresses at runtime

The email fixtures were literals, so this branch's own push listed 47
pii.email findings in its test file. Build them from a helper instead, the
way the neighbouring tests build credential and IP fixtures.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(browse): offer the user's signed-in tab, name silent aside repl failures

Rules (rendered into every browsing skill, kept short):
- Rule 1: before the first openTab, offer the user's tabs on the target
  origin (title and origin only; the rest of listBrowserTabs() stays
  private) and attach only after the user confirms one.
- Rule 4: a second sign-in wall after a confirmed sign-in means the session
  is bound to the tab or URL; offer that tab instead of another sign-in.
- Rule 6 no longer suggests an early return; rule 7 says a fast [ok without
  GSTACK_STEP_OK is an abort.

Cookbook (browse, devex-review): a "Silent failures" list (evaluate returns
only serializable values, no top-level return, locator(sel).press(key), an
empty DOM read is about the selector until the screenshot and the request's
response say otherwise, read toggle state before clicking) and a signed-in
tab recipe that prints only target-origin tabs and never closes the user's tab.

Parity caps for design-consultation, land-and-deploy, qa and the browse
skeleton are raised to the measured sizes, with notes.

Refs #3063, #3064.

Co-authored-by: Thomas Gernhardt <t.gernhardt@softwareprojekt.net>
Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* feat(codex): run gstack-codex-probe as a command, one subcommand per probe

Generated skills now execute bin/gstack-codex-probe (select-model, check-auth,
show-sandbox, check-sandbox, probe-model, check-version, show-first-use-notice,
run-with-timeout, log-event, log-hang, help) and capture its KEY: value lines,
so no helper state crosses into the calling shell and the preflight works from
bash, zsh or sh. select-model keeps --model > GSTACK_CODEX_MODEL > config.toml
precedence; run-with-timeout supervises with the existing gtimeout/timeout/
watchdog chain and returns 124 on a deadline; an unknown subcommand exits 64.

Sourcing keeps working for skills rendered before the upgrade and prints one
deprecation line naming /gstack-upgrade; it and the zsh self-locate block are
removed in a release on or after 2026-10-21 (DX-18). Parity caps raised with
measured notes for the longer capture lines.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* feat(gstack-post): one argv-only, redaction-scanned write path for PR and issue text

bin/gstack-post posts a PR/MR or issue comment, a review-comment reply, a
PR title or body, a new PR/MR or a new issue from agent-written files. Every
value reaches gh/glab as its own argv element in --flag=<value> form or on
stdin, never through a shell string, and a target is a number or a URL of
this repository on the same host.

The helper owns the redaction scan: it reads each file once, scans those
exact bytes (visibility from config, then gh/glab; the pusher's own email
suppressed) and sends the same bytes. HIGH is refused with exit 1 and no
confirmation can post it. MEDIUM exits 2 with RULE:/LINE:/PART: lines and a
TOKEN: digest of the bytes, destination, operation and findings; only
--confirm <token> for those exact bytes posts, so any edit needs a new
confirmation. gh/glab failures exit 3, usage errors 64. It also carries the
projectCards REST fallback and the title read-back that /ship did by hand.

The logic lives in lib/gstack-post.ts behind an injectable runner, so its
tests run in the Windows free lane; the stub-gh executable test is POSIX.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(autoplan): guard verifies dispatches on Claude Code 2.1.29x (schema strip, unflushed call, named causes)

Cause A: Claude Code journals the model's raw Agent input but hands
PreToolUse the schema-parsed input; with the fork-subagent gate on (the
interactive default in 2.1.292) run_in_background is dropped, so the journal
record never deep-equaled the payload. nativeToolInput now drops only that
documented strip for Agent. Agent input is bound on both paths: keys limited
to prompt, description, subagent_type (general-purpose) and
run_in_background; a model override or any other key is denied.

Cause B: when a ready journal lacks the current call, the guard evaluates
the payload placed after the last journaled record instead of polling for a
record that may arrive only with the tool result. A phase transition counts
a report only when a later journaled record follows it (and, on the journal
path, it is not in the current call's message). One batch rule covers both
paths; a background reviewer keeps the invocation armed until its
completion notice.

Every outcome now has a stable reason code, disposition and anchor
(autoplan/bin/guard-reasons.ts). UC1: Claude-Code-caused states
(unrecognized shape, journal lag, rewritten journal, oversized record,
unchecked-version schema strip) allow with a visible warning; integrity
failures stay denials. No denial advises a bare retry. Every guarded
decision appends one content-free line to analytics/autoplan-guard.jsonl,
trimmed to 1,000 lines past 256 KiB.

Co-authored-by: Jared <182125291+yolo-jared@users.noreply.github.com>
Co-authored-by: crblabs <293123359+crblabs@users.noreply.github.com>
Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(autoplan): publish each phase report with a no-op call; foreground requests are conditional

Phase-close step 6 sends the report in a message whose only tool call is
the Bash no-op ': autoplan-published <phase>', and step 7 makes the next
guarded call in a later message, so the guard sees the report flushed
before the next phase entry regardless of Claude Code's journal timing.

Every site that asked for run_in_background: false now asks for it only
when the Agent schema offers it and says how to recover when a dispatch
runs in the background anyway (wait for its completion notice). Parity
caps rise by the measured bytes.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* feat(ship,spec,review): PR and issue text goes out only through gstack-post

/ship: Step 18 writes the title into an agent-written file. An existing PR's
title is piped from gh/glab through gstack-pr-title-rewrite.sh --stdin (new),
so neither the agent nor a shell string carries it; a new title is written
with the file tool and its version prefix checked in the file. Step 19
composes the body as before and publishes with gstack-post pr-create, or
pr-body then pr-title, which scan the exact bytes they send. The separate
title and body scans, the hand-rolled REST fallback and the title self-check
are gone (the helper does all three). Title preparation moved into the
pr-body section, so the skeleton shrinks.

/spec files its issue with gstack-post issue-create and drops the pre-issue
re-scan; Greptile replies use gstack-post reply and pr-comment.
scripts/resolvers/redact-doc.ts loses its PR and issue sinks, and a test
keeps any template from rendering one again.

Tests that pinned the old scan-then-gh wiring now pin the gstack-post wiring;
the publication tests run the real compose and publish blocks against a stub
gh with the real helper (HIGH in title or body refused, MEDIUM token flow).

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* ci: pin Claude Code 2.1.292 in the CI image

2.1.292 is the npm latest users run. Its interactive default turns on the
fork-subagent gate, which strips run_in_background from the Agent schema
and backgrounds reviewers; CI on 2.1.284 never saw the /autoplan guard
break. The image tag is a content hash, so every eval workflow picks up
the new image without a workflow edit.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(brain-sync): one drain lock for every writer to the artifacts repo

gstack-artifacts-init, gstack-brain-restore, gstack-gbrain-source-wireup
and the skill-start merge ran git in $GSTACK_HOME without the drain's lock,
so the drain could never tell an abandoned .git/index.lock from a live one.
They now take the same mkdir lock (bin/gstack-brain-lock.sh): the drain and
the skill-start merge skip when it is held, user-run writers wait for it
(GSTACK_BRAIN_LOCK_WAIT, default 120 s), and a child of the holder (the
drain's daily worktree advance, restore's wireup) inherits it by token.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(brain-sync): hold back only the flagged file, keep coupled artifacts whole

One file with secret-shaped text used to block every push, silently. The
drain now attributes scanner hits to files in one pass over the staged diff
(split on its diff --git headers), holds back each flagged file with the
rest of its coupled group, unstages it, and requires the remaining staged
diff to re-scan clean; anything short of that falls back to a full unstage
and status blocked. Held files stay queued and are re-scanned every drain.

- Status file gains held_count, drainable, last_drain_at, last_push_at and
  held[] (path, scanner rule, dependents, both fixes); new status held.
- Coupled groups come from an explicit map (decisions.jsonl and
  decisions.active.json): a queued member stages the whole group, a group
  stages only when its snapshot matches its log in the index, a skipped
  member stops the whole group.
- --unskip-file undoes --skip-file and queues the path again.
- An index lock older than 10 minutes is removed under the drain lock; a
  younger one, a failed git add, a failed commit (hooks included) keep the
  queue and report status error. A verified empty staged diff is the only
  "nothing to commit". git add runs once, batched.
- The scanner reads bytes, so undecodable content no longer crashes it into
  a false clean; matched text never reaches the status file.
- An empty-queue run with unpushed sync commits stays push_failed.
- Privacy-held duplicate records collapse to one per path; --status counts
  a spool too deep for a shell glob.
- --attention prints skill start's fixed attention lines from the sync
  status table in the usage header.

Co-authored-by: v639dragoon <matthewsbrickley@gmail.com>
Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* feat(skill-start): ARTIFACTS_SYNC attention lines for a stuck sync

Skill start now prints one fixed attention line per sync-status-table row
that applies (held, blocked, push_failed, error, unknown, stale-push,
stale-drain), each naming gstack-brain-sync by absolute path. Values from
the status file are clamped (status code to the table, counts to digits,
timestamps to their shape), so the status message, file paths and scanner
output never reach the line. The preamble tells the model to surface the
line in one sentence and continue. Skill-start tests are generated from the
table in bin/gstack-brain-sync, and docs/gbrain-sync-errors.md carries the
same table.

Co-authored-by: v639dragoon <matthewsbrickley@gmail.com>
Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(outside-review): severity words in label position count as findings

The Oct 7 /autoplan run's Codex CEO and DX reviews labeled seven and eight
findings High/Medium without [Pn] tags, and the classifier printed
VERDICT: clean / FINDINGS: none for both. lib/outside-review-result.ts now
reads severity words in label position (Severity: High, a leading High: /
High — / [High], **High**, a table cell): critical/high block like P0/P1,
medium/low are advisory. Words in prose (high-level, low-risk, no critical
findings) never count. A review or structured response with neither tags,
labels nor an explicit no-findings statement is unverified, never clean
(DX-11, ENG-10). Design-direction proposals move to a new proposal gate so
they keep needing only their Recommendation line, and review prompts ask
for a severity per finding. Fixtures reproduce the CEO/DX label shapes, the
eng [P1] output, a table and prose negative controls; the stored Codex panel
keeps its verdicts. docs/troubleshooting.md explains how the verdict is read.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* feat: gstack-doctor readiness report and setup --status Codex row (B5)

bin/gstack-doctor prints one row per check without starting a skill:
install root (the registry rows behind ./setup --status), state root, Bun
against the floor, hook parse check, Codex mode and self-locate via
gstack-codex-probe subcommands, the cached model probe with its age
(--live runs the paid probe-model), artifacts-sync health from the status
file with the status code clamped, the browse bundle, Claude Code version,
the largest session journal and the last five schema-1 guard reason codes.
Rows are ok, warn, not configured or fail; only fail exits non-zero; fix
lines name helpers by absolute install-root path.

./setup --status gains a read-only Codex row (bin/gstack-codex-status.sh,
shared with the doctor) and ends with the doctor's absolute path.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* docs: bug-report template asks for doctor output; README troubleshooting entry; doctor test in the Windows lane

The template gives the Claude Code doctor path and a lookup for other
hosts and names no bare gstack- command (asserted in
test/gstack-doctor.test.ts). The doctor test runs every script through
explicit bash argv, so it joins the curated Windows free subset.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* docs(troubleshooting): readiness check section points at gstack-doctor

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(question-tuning,plan-tune,gbrain): free text reaches helpers only through agent-written files

Question tuning no longer pipes the question summary through printf: a
registered id needs no summary, and for an unregistered id the agent writes
the summary to .gstack/tmp/qt.txt and passes --summary-file (new). The
helper resolves a relative path against the git top level, removes scratch
files under .gstack/tmp, and asks normally when the file is missing.

/plan-tune tune events carry the user's own words again: they go into a
file the agent writes and reach gstack-question-preference --write through
--free-text-file (new), still behind the injection filter and the
user-origin gate.

docs/gbrain-write-surfaces.md drops its heredoc templates for the
agent-written page file on stdin, matching the per-skill save block, and the
generic save block stops showing a quoted --content argument.

The tuning prose was tightened so every preamble stays within its size cap.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* test(evals): daily autoplan-schema-canary on the latest Claude Code

A periodic rule case installs the latest published Claude Code with
install scripts off, verifies registry signatures, and runs one headless
session with the fork-subagent gate on whose PreToolUse hook records an
Agent and a Read payload. Each payload must match its journal record under
the guard's own comparison, keep the journal's key set apart from the
documented run_in_background strip, and stay inside the Agent allowlist;
a background Agent's completion notice must keep the shape the guard reads.
evals-periodic.yml runs it daily on its own schedule and concurrency group
(read-only token); the weekly census also includes it. A free test proves
the comparison fails on an injected strip.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(doctor): read the artifacts sync held count from held_count, the field the drain writes

* fix(artifacts sync): the init and restore pre-commit hooks catch Bearer/Basic/Token-prefixed JSON auth headers like the drain does

* feat(greptile-early): detect Greptile, ask once on public repos, open the early draft, wait for the review

bin/gstack-greptile-early backs /ship's early Greptile PR:
- detect: a root .greptile/ folder (which takes precedence), greptile.json,
  or a Greptile comment on the repo in the last 90 days; triggerOnDrafts from
  the effective root config; repo visibility; public-repo consent. It prints
  the signal, that /ship will push and open a draft now, the 10-minute wait
  cap and the absolute gstack-config command that turns it off.
- consent yes|no: the public-repo answer, remembered per repo in the
  project's state.
- open: opens the draft through gstack-post with a body saying /ship opened
  it early, and posts one @greptileai comment through gstack-post when the
  config does not set triggerOnDrafts: true. An open PR is left alone.
- wait: polls every 30 s for a completed Greptile check run, a Greptile
  review of the head commit or a summary naming it; each call returns within
  about 90 s and reports timeout 10 minutes after the PR opened.

gstack-config gains ship_greptile_early (default true, invalid values
rejected): on automatically whenever the repo uses Greptile, off per user.
The logic is in lib/greptile-early.ts behind an injectable runner, so its
fixture-repo tests run in the Windows lane; an end-to-end test drives the
real helper and gstack-post against a stub gh.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* feat(ship): early Greptile PR at Step 6.5, bounded wait at Step 10 (#3020)

When the repo uses Greptile, /ship pushes and opens a draft PR right after
its free tests pass (new lazy section greptile-early, Step 6.5), so Greptile
reviews while Steps 7-9 run. A public repo asks once, remembered per repo;
declining keeps today's order. Step 10 waits for that review with
gstack-greptile-early wait and takes the existing unavailable route on a
timeout, never a claim of zero comments. Step 18 replaces the provisional
title, Step 19 marks the draft ready unless a draft was requested, and a
/ship that stops after Step 6.5 leaves the draft open with one comment
saying why.

ship's union cap rises to 1.5275 with the measured note (B4 +836 bytes,
B2 +4,732 bytes); the step-numbering guard allows 6.5; ship goldens are
refreshed for B4 and B2.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(autoplan): the publication no-op is 'true autoplan-published <phase>'

Measured on Claude Code 2.1.292 in a default-settings interactive session:
a bare ':' Bash command asks for approval ('This command requires
approval'), and after a background reviewer's completion notice starts a
new turn the skill's allowed tools no longer cover it, so the phase-close
no-op prompted the user. 'true' with arguments runs without approval and
prints nothing. The guard only needs a later journaled record, so the
command changes everywhere it is named.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* test(evals): live autoplan-guard-pty case on the pinned Claude Code

A gate-tier rule case (one trial, haiku) drives an interactive PTY
session with default settings through a project skill that carries
/autoplan's own hook block: init, Phase 1 entry, a CEO reviewer dispatch
that sends run_in_background, a prepared close packet, the report
published with the no-op, and the Phase 2 entry in a later message. It
reads outcomes from the guard decision log (three verified allows) and
fails if the no-op raises a permission card; other cards are approved and
printed.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* fix(autoplan): bounded, append-tolerant owned-journal read (A2)

The publication guard no longer reads the whole parent journal or refuses
it at 32 MiB. lib/claude-owned-journal.ts streams the bytes present at open
to the last complete line (pass one), keeps a content-free index per record
and decides ownership, ancestry and causal order on it with the same checks
and reason codes as before. Pass two reloads in full only what the
evaluation reads (autoplan/bin/guard-journal.ts): every literal init and its
result, the current call, and inside the invocation window (from the latest
human turn at or before the bound chain's first init) guarded and
close-packet Read results, structured Bash results, error results, assistant
text after the first close Read and active-plan mutations, plus the earlier
Read a dedup reply cites even before the window (ENG-4).

- lib/claude-journal-records.ts: per-record event extraction, record
  metadata and the causal-order checks, shared by readPlanCountTranscript
  and the bounded reader. The batch reader keeps its whole-file read and cap.
- Appends after open never fail a read; same device and inode and no
  shrink are required (identity). A second read in one hook invocation must
  hash bytes [0, first size) the same, or it is `rewritten` (UC1 unverified);
  the unrecognized-shape double read uses that prefix hash. `changing` is
  removed (REMOVED_CODES; its anchor stays).
- OWNED_RECORD_MAX_BYTES (32 MiB): only one record over it is too_large.
  OWNED_RETAINED_MAX_BYTES (32 MiB): over it is the new oversized_invocation
  fallback denial. GSTACK_TRANSCRIPT_TEST_MAX_BYTES and
  GSTACK_TRANSCRIPT_TEST_RETAINED_BYTES can only lower them.
- ENG-5: evaluation groups uses and results by tool id once (no per-tool
  rescans).

CEO-25 / ENG-5 spike (120 MiB synthetic, 31,242 records, 4 vCPU Linux,
Bun 1.4.2): a full streaming rescan (parse every line, small index, sha256)
took 254-326 ms at 147-161 MiB peak RSS; a pass-one index cache under the
state root (load cached index, verify a 64 KiB tail hash, parse the tail)
took 26-29 ms at 47 MiB. The rescan meets the 1 s budget, so the cache is
not adopted: it would add trusted persistent state and invalidation for no
budget need. A backward tail read cannot prove competing_root or cycle, so
it was not a candidate.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* test(autoplan): journal-read benchmark and its dispatch-only workflow (CEO-2, CEO-6)

scripts/measure-journal-read.ts builds two synthetic 120 MiB parent journals
around a real /autoplan invocation (mixed: ~28k records, most bytes inside
the invocation; large-invocation: ~89k records with a current invocation of
many small records), keeps appending while the guard reads, and measures one
hook call in a fresh process (wall ms, peak RSS). The workflow runs it on
ubuntu-latest and macos-latest on workflow_dispatch only.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* test(evals): autoplan-long-session, a resumed >100 MiB session enters Phase 1

CEO-15 with ENG-6's observer: a real session is compacted, its journal
padded past 100 MiB with owned records before the compact boundary, and
the resumed interactive session runs the scripted phase boundary; the
guard decision log must show a verified Phase 1 allow. A free test proves
that observer on a padded journal through the lower-only bound seams
(the PTY counting reader refuses the same journal), with a sidechain
control that must deny.

Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>

* v1.91.34.0: CHANGELOG, TODOS, version; harness decision for test-pr-profile; ship title-step test reads its new section

* docs(changelog): use an example.com address in the allowEmail example

* test: assemble GitHub-token fixtures at runtime in the new brain-sync and skill-start tests (CI credential scan)

* fix: integration repairs across the wave (Step 6.5 fence, printed helper paths on Windows, probe usage without a heredoc) and tests pinned to the moved title and gstack-post contracts

* test(doctor): the healthy fixture builds browse.exe on Windows, the name setup uses there

* test(shared-libs): recognize Claude Code 2.1.292's internal git probe prefix (format.pretty and per-hook disables), with its CI receipt

* fix(ship-measure): report lists v1 measurements as an older format instead of crashing

---------

Co-authored-by: Mike Ilog <48659643+Mike-E-Log@users.noreply.github.com>
Co-authored-by: capy-ai[bot] <230910855+capy-ai[bot]@users.noreply.github.com>
Co-authored-by: Thomas Gernhardt <t.gernhardt@softwareprojekt.net>
Co-authored-by: akmandhania <143462686+akmandhania@users.noreply.github.com>
Co-authored-by: Jared <182125291+yolo-jared@users.noreply.github.com>
Co-authored-by: crblabs <293123359+crblabs@users.noreply.github.com>
Co-authored-by: v639dragoon <matthewsbrickley@gmail.com>

2026-10-07 23:29:05 +00:00

22 KiB

Raw Blame History

gbrain-sync error lookup

Every error message gstack-brain-* can print, with problem, cause, and fix.

Search this file by the prefix after BRAIN_SYNC: or by the binary name in the command output.

`BRAIN_SYNC: brain repo detected: <url>`

Problem. You're on a machine that has ~/.gstack-artifacts-remote.txt (or the legacy ~/.gstack-brain-remote.txt, copied from another machine) but no local git repo at ~/.gstack/.git.

Cause. You've set up GBrain sync elsewhere and your gstack hasn't been restored on this machine yet.

Fix.

gstack-brain-restore

This pulls the repo into ~/.gstack/ and re-registers merge drivers.

If you don't want to restore here, dismiss the hint with:

gstack-config set artifacts_sync_mode_prompted true

`ARTIFACTS_SYNC: attention: ...` at skill start

Problem. The artifacts sync is stuck or partly stuck. Skill start prints one fixed line per problem; ok and idle print nothing. Every line names the absolute path of gstack-brain-sync; run it with --status to see the cause, the held files and the fix.

State	Trigger	Attention line (after `ARTIFACTS_SYNC: attention:` )	Fix
`held`	The secret scan held back flagged files and synced the rest	`status=held held=<N>. The secret scan is holding back <N> file(s); everything else still syncs. See which files and how to fix them: <bin> --status`	Edit the file so the scan no longer matches, or `<bin> --skip-file <path>` (permanent; undo with `--unskip-file <path>`)
`blocked`	A re-scan still flagged after the hold, so nothing was committed	`status=blocked. The secret scan flagged a file it could not hold back on its own, so nothing is syncing. See the fix: <bin> --status`	Edit or skip the files `--status` names, or clear the batch with `<bin> --drop-queue --yes`
`push_failed`	A commit is saved locally but the push failed	`status=push_failed. Synced files are committed locally but the push failed; it retries at skill start. See the cause: <bin> --status`	The fix `--status` names (usually `gh auth status`)
`error`	The drain stopped before committing and kept the queue	`status=error. The last sync stopped before committing; the queue is kept and retried. See the cause: <bin> --status`	The cause `--status` names: a git index lock, a commit hook, a `git add` failure
`unknown`	The status file holds a status code outside this table	`status=unknown. The sync status file is unreadable. See it: <bin> --status`	Run `<bin> --once` to rewrite it
stale-push	No push for 24 hours while the drain's `drainable` count is above zero	`stale-push. Files are ready to sync but nothing has been pushed for over 24 hours. See why: <bin> --status`	The waiting reason `--status` names (a coupled group waiting for a consistent generation, a `git add` failure)
stale-drain	`last_drain_at` older than 24 hours while the queue holds records	`stale-drain. The sync has not run for over 24 hours while files wait in the queue. See why: <bin> --status`	If no gstack process is running, remove `~/.gstack/.brain-sync.lock.d`, then run `<bin> --once`

<bin> is the absolute path, for example ~/.claude/skills/gstack/bin/gstack-brain-sync. The source of truth is the usage header of bin/gstack-brain-sync; skill start's tests are generated from it.

Held files. When the secret scan flags a file, only that file is held back (with any file coupled to it, such as a decision log and its active snapshot); everything else syncs. The held file stays queued and is re-scanned on every sync, so editing it clears the hold automatically. --status lists each held file under held, with the scanner rule that matched (never the matched text), the files held with it (dependents) and both fixes:

If it's a real secret: edit the file to remove it. The next skill run re-scans and syncs it.
If the match is a false positive you never want synced:
```
~/.claude/skills/gstack/bin/gstack-brain-sync --skip-file <path>
```
This permanently excludes the path from future syncs (for a coupled file, the files coupled with it stop too). To undo it and queue the path again:
```
~/.claude/skills/gstack/bin/gstack-brain-sync --unskip-file <path>
```

To abandon the whole batch (start fresh):

~/.claude/skills/gstack/bin/gstack-brain-sync --drop-queue --yes

Git index lock. A git process killed mid-write leaves ~/.gstack/.git/index.lock. The sync removes it once it is older than 10 minutes, because every gstack writer to ~/.gstack takes the same sync lock first. A younger lock means a git process is running there; the sync reports error and retries at the next skill start.

`BRAIN_SYNC: push failed: auth.`

Problem. Git push was rejected because your auth with the remote expired or is missing.

Cause. The remote is unreachable with current credentials.

Fix. Refresh auth based on your remote:

GitHub: gh auth status (then gh auth refresh if needed)
GitLab: glab auth status
Other: git remote -v + check SSH keys or credential helper

After fixing auth, run any skill to retry sync automatically.

`BRAIN_SYNC: push failed: <first-line-of-error>`

Problem. Push failed for a reason other than auth. The first line of git's error appears after the colon.

Cause. Could be network issue, rejected push (remote ahead), server 500, or repo access revoked.

Fix. Look at ~/.gstack/.brain-sync-status.json for more detail, or run:

cd ~/.gstack && git status && git push origin HEAD

to see git's full error. The queue is cleared after any push attempt, but your local commit still exists — the next skill run will retry the push.

`gstack: brain-sync push NOT sent — the egress receipt could not be written`

Problem. The push was refused before anything left your machine. Every brain-sync push writes a tamper-evident receipt to the egress ledger (~/.gstack/security/egress.jsonl) before sending, fail-closed. The receipt could not be written, so nothing was sent, no local commit was made, and the queue is preserved — the next run retries the whole drain. gstack-brain-sync --status shows EGRESS_RECEIPT_FAILED as the failure detail.

Cause. ~/.gstack/security/ is not writable (the receipt writer creates it when missing, so absence alone is not the cause), the disk is full, or GSTACK_HOME points at a read-only location.

Fix.

mkdir -p ~/.gstack/security && chmod -R u+w ~/.gstack/security

Then run any skill (or gstack-brain-sync --once) to retry. Inspect the ledger with gstack-egress list; verify its hash chain with gstack-egress verify.

`gstack-artifacts-init: ~/.gstack/ is already a git repo pointing at: <url>`

Problem. You tried to init with a remote URL that doesn't match the existing one. The command refuses to overwrite.

Cause. You already ran gstack-artifacts-init with a different remote.

Fix. Either:

Use the existing remote: run gstack-artifacts-init without --remote, or with the matching URL.
Switch remotes: git -C ~/.gstack remote set-url origin <url> (the command's own suggestion), or gstack-brain-uninstall first, then re-init with the new URL. Neither deletes your data.

`Remote not reachable via SSH: <url>`

Problem. Init couldn't reach the git remote to verify connectivity.

Cause. Wrong URL, missing auth, network issue.

Fix. Test manually:

git ls-remote <url>

If that fails, check:

URL spelling
GitHub: gh auth status
GitLab: glab auth status
Private network / VPN / DNS

`Failed to create or find '<name>'. Try --remote <url>.`

Problem. Auto-repo-creation via gh repo create failed and the repo isn't discoverable via gh repo view either.

Cause. gh is unauthenticated, a repo with that name already exists owned by someone else, or your GitHub account hit a quota.

Fix.

gh auth status

If unauth'd, run gh auth login. If the repo name collides, pass a different name:

gstack-artifacts-init --remote git@github.com:YOURUSER/custom-name.git

`gstack-brain-restore: ~/.gstack/.git already points at <url>`

Problem. You tried to restore from a URL that doesn't match the existing git config.

Cause. Stale .git from a previous init with a different remote.

Fix. gstack-brain-uninstall, then re-run gstack-brain-restore <url>.

`gstack-brain-restore: ~/.gstack/ has existing allowlisted files that would be clobbered`

Problem. You're trying to restore, but ~/.gstack/ already contains learnings or plans that would be overwritten.

Cause. Either (a) this machine has accumulated state from a pre-sync gstack session, or (b) a previous failed restore left partial state.

Fix (three options).

If this machine's state should become the new truth: run gstack-artifacts-init instead of restore — this creates a brand-new brain repo from this machine's state.
If you want to adopt the remote and discard this machine's state: back up ~/.gstack/projects/ first, then remove the offending files and re-run restore.
If you want to merge: there's no automatic merge for this. Manually copy learnings from ~/.gstack/ into your running gstack on a machine with sync already on, then restore here.

`gstack-brain-restore: <url> does not look like a gstack-brain repo`

Problem. The clone succeeded but the repo is missing .brain-allowlist and .gitattributes.

Cause. You pointed restore at a random git repo, or someone deleted the canonical config files from the brain repo.

Fix. Verify the URL. If it's correct, run gstack-artifacts-init --remote <url> to re-seed the canonical config.

`database host unreachable (<code> <host>); your gbrain config is unchanged. Fix: check network or VPN, then re-run /sync-gbrain.`

Problem. /sync-gbrain skipped the code, memory and dream stages, or /setup-gbrain reported gbrain_local_status: db-unreachable.

Cause. gbrain could not reach the database named in ~/.gbrain/config.json because of a network error (ENOTFOUND / EAI_AGAIN in an offline sandbox, a VPN that is down, a refused or timed-out connection). Nothing is known to be wrong with the config, so gstack leaves it alone and keeps brain-aware skill blocks rendered, the same way it treats a slow timeout.

Fix. Restore network access (or the VPN), then:

/sync-gbrain

Do not move ~/.gbrain/config.json aside; that remediation is only for broken-db / broken-config.

`[memory-ingest] ERR: gbrain import accounted for N-1 of N staged page(s) ... Refusing to advance state` on every run (a `.claude`-style project)

Problem. Before this release, ingest refused every batch that held a page from a project whose slug starts with a dot (for example .claude), on every run.

Cause. gbrain's import walker skips every path segment that starts with a dot, so the staged page was never collected.

Fix. Nothing to do after upgrading: such slugs now stage as dot-claude, and state recorded under the old name maps to the new one. Run /sync-gbrain once to import the pages that were stuck.

`[memory-ingest] FAILED <path>: <error> (left un-stamped; retried next run)`

Problem. gbrain refused one staged page during /sync-gbrain's memory stage (for example invalid frontmatter or an oversize page).

Cause. gbrain import named the page as a per-file failure (in its --json failures list or a Skipped <path>: line). Before this release, such pages were marked ingested and never retried.

Fix. Nothing is lost: the page is not marked ingested and is retried on every run. If the same page keeps failing, read the error, fix the source file it came from, then run /sync-gbrain.

`[memory-ingest] re-queued <slug>: not found in gbrain source <id> after import (retried next run)`

Problem. gbrain said a page was imported (or unchanged), but the landing check could not find it in the source it was imported into, or found different content.

Cause. Usually a managed import that was accepted but is still publishing (Pending: in gbrain's output), or a page gbrain skipped without naming it.

Fix. Nothing to do; the next /sync-gbrain imports it again. If it repeats on every run, upgrade gbrain (gstack-gbrain-install).

`[memory-ingest] ERR: gbrain reported N failure(s) it did not attribute to a staged page ... Refusing to advance state.`

Problem. The memory stage failed and marked nothing ingested.

Cause. gbrain counted failures it did not name (it stops printing them after five of the same kind), so gstack cannot tell which pages landed.

Fix. Re-run /sync-gbrain. After three refused runs the batch is split in halves automatically to find the page gbrain cannot import; that page is quarantined (next entry) and the rest import.

`[memory-ingest] quarantined <slug> (<source path>): gbrain refuses every batch that contains it (...)`

Problem. One page kept making gbrain refuse the whole batch.

Cause. After three refused batches, gstack imported the batch in halves until it isolated the page. Every other page was imported.

Fix. The page is retried automatically when its source file changes. To retry now, fix or remove the source file named in the message, then run /sync-gbrain.

`[memory-ingest] reconcile: checked N, present M, re-queued K, not yet checked L (run again to continue)`

Problem. Not an error. This is the one-time catch-up after upgrading: gstack re-checks transcripts it had marked ingested and re-queues the ones missing from the brain, so transcripts lost by older versions import again.

Cause. Older versions could mark a page ingested that gbrain had skipped. The upgrade records that a reconcile is pending; each ingest run then checks a bounded batch (200 entries) until done.

Fix. Nothing to do; each /sync-gbrain continues where the last one stopped. To run it now or check progress:

gstack-memory-ingest --reconcile --dry-run   # report only
gstack-memory-ingest --reconcile             # re-check the next 200 (--limit N)

"not yet checked" counts pages whose lookup failed (gbrain busy or unreachable); they are never treated as missing. "unrecoverable" counts pages missing from the brain whose transcript file no longer exists. The state file is backed up to ~/.gstack/.transcript-ingest-state.json.pre-reconcile.bak before each pass.

`[memory-ingest] reconcile: not run (...)`

Problem. A reconcile pass was requested but could not run.

Cause. gbrain is not installed or lacks import, or the brain is a remote-HTTP brain (its pages are staged for the brain admin's pull, so there is nothing to check locally).

Fix. For a missing gbrain, run /setup-gbrain, then gstack-memory-ingest --reconcile. For a remote-HTTP brain, nothing to do.

`[memory-ingest] ERR: another memory ingest (pid <N>) is writing <state file>; not run.`

Problem. The memory stage did nothing this run.

Cause. Another ingest, reconcile or --request-reconcile holds the state lock (~/.gstack/.transcript-ingest-state.json.lock). A lock left by a process that no longer exists is taken over automatically.

Fix. Wait for the other run to finish, then run /sync-gbrain again.

`[memory-ingest] ERR: could not save ingest state <path>: <error>.`

Problem. The memory stage failed after importing.

Cause. The state file could not be written (disk full, permissions, or a directory in its place). The run fails instead of pretending it recorded progress; pages it imported are re-checked next run, which is cheap because gbrain skips unchanged content.

Fix. Free disk space or fix permissions on ~/.gstack/, then run /sync-gbrain.

`[memory-ingest] kept N unattributed transcript(s) on this machine: the brain is remote (Postgres or HTTP), ...`

Problem. --include-unattributed transcripts (sessions with no git remote) were not imported.

Cause. Transcripts that cannot be attributed to a repository go only to the machine-local, never-federated source gstack-transcripts-unattributed. Your brain is remote (a Postgres or Supabase database_url, or a remote-HTTP MCP brain), so sending them would take them off this machine. They are not marked ingested and are not written to the publishable ~/.gstack/transcripts/ staging either.

Fix. Nothing to do if that is what you want. To include such a session, run it from a git repository with an origin remote so it is attributed.

`[memory-ingest] kept N transcript page(s) for <repo> on this machine: could not register gbrain source <id> (...)`

Problem. Transcripts from one repository were not imported.

Cause. gstack imports each repository's transcripts into that repository's own gbrain source (gstack-transcripts-..., machine-local and not federated) and registers it before the first import. The installed gbrain refused gbrain sources add, so the pages stay local and unstamped.

Fix.

gstack-gbrain-install      # upgrade gbrain
/sync-gbrain               # the pages import on the next run

`curated artifacts pushed to git, but gbrain source <id> has 0 indexed pages. Fix: gbrain sync --source <id>, then re-run /sync-gbrain`

Problem. /sync-gbrain's brain-sync stage is ERR even though the git push worked.

Cause. The push only moves your curated artifacts to git. gbrain indexes them separately, and the artifacts source this machine maintains reports zero pages, so searches return nothing from it. Before this release the stage said "curated artifacts pushed" and passed.

Fix.

gbrain sync --source <id>
/sync-gbrain

If it stays at zero, re-register the source with gstack-gbrain-source-wireup.

`[gbrain-sync] gbrain source <id>: path unavailable (<path>); gstack skips it.`

Problem. A gbrain code source points at a directory that no longer exists on this machine, usually a deleted Conductor worktree. gbrain's autopilot keeps failing on it.

Cause. Each worktree gets its own gstack-code-<repo>-<hash> source. Deleting the worktree leaves the source behind. gstack does not remove it on its own: its indexed pages may be the only copy of work that was never committed, and a source can belong to another machine sharing the brain.

Fix. Review, then remove the ones gstack can prove are gone:

gstack-gbrain-sync --prune-gone-worktrees --dry-run
gstack-gbrain-sync --prune-gone-worktrees

A source is removed only when its path was missing on two consecutive syncs, its parent directory is readable, its id recomputes from this host and path (so this machine created it), and its repository still exists but no longer lists the worktree. Each removal is logged to ~/.gstack/.gbrain-prune.log. Run it from the main checkout of the same repository so gstack can find the repository. Anything it keeps prints the reason; remove such a source by hand with gbrain sources remove <id> only if you are sure.

`dream: skipped — the installed gbrain cannot run only the resolve_symbol_edges phase, and the full dream cycle costs about 35 minutes (LLM phases).`

Problem. /sync-gbrain --dream (or --full) did not build the call graph.

Cause. The call graph needs only gbrain's resolve_symbol_edges phase. The installed gbrain cannot run that phase alone (no dream --phase, or no such phase), and gstack no longer starts gbrain's full maintenance cycle on its own: it takes about 35 minutes and runs LLM phases.

Fix.

gstack-gbrain-install          # upgrade gbrain, then:
/sync-gbrain --dream

Or run the full cycle yourself when you have the time: gbrain dream --source <id>.

`call graph for <source>: unknown: installed gbrain does not expose cycle_freshness`

Problem. /sync-gbrain cannot tell whether this repo's call graph was ever built, so it does not offer to build it.

Cause. The answer comes from gbrain doctor's cycle_freshness check. gstack now reads it from gbrain doctor --json --scope=brain (the --fast mode it used before skips that check, so it always said "unknown"). Your installed gbrain does not report the check at all.

Fix.

gstack-gbrain-install          # upgrade gbrain
/sync-gbrain --dream           # or build the call graph now regardless

`artifacts remote: restored <url> because <owner>/gstack-artifacts-<user> does not exist and <owner>/gstack-brain-<user> does`

Problem. Printed once during upgrade. Artifact pushes had been failing because ~/.gstack-artifacts-remote.txt named a repository that was never created.

Cause. The v1.27.0.0 upgrade passed a bare repo name to gh repo rename, which always fails, then rewrote the remote to the new name anyway. This upgrade points the remote (and ~/.gstack's origin) back at the repository that exists.

Fix. Nothing is required; pushes work again. To finish the rename:

gh repo rename gstack-artifacts-<user> --repo <owner>/gstack-brain-<user> --yes
GSTACK_MIGRATE_ASSUME_YES=1 bash ~/.claude/skills/gstack/gstack-upgrade/migrations/v1.27.0.0.sh

If it instead says it could not confirm ... exists (gh is not installed or not signed in), run gh auth login and check the repository name on GitHub.

Nothing is syncing but I expect it to

Not an error, but a common gotcha. Check in order:

gstack-brain-sync --status — is mode off?
~/.gstack/.git exists?
gstack-config get artifacts_sync_mode — should be full or artifacts-only.
The file you expect to sync — is it in the allowlist? cat ~/.gstack/.brain-allowlist
Privacy class filter — if mode is artifacts-only, behavioral files (timelines, developer-profile) are intentionally skipped.

If all those look right, run:

gstack-brain-sync --discover-new
gstack-brain-sync --once

to force a drain.

22 KiB Raw Blame History

gbrain-sync error lookup

BRAIN_SYNC: brain repo detected: <url>

ARTIFACTS_SYNC: attention: ... at skill start

BRAIN_SYNC: push failed: auth.

BRAIN_SYNC: push failed: <first-line-of-error>

gstack: brain-sync push NOT sent — the egress receipt could not be written

gstack-artifacts-init: ~/.gstack/ is already a git repo pointing at: <url>

Remote not reachable via SSH: <url>

Failed to create or find '<name>'. Try --remote <url>.

gstack-brain-restore: ~/.gstack/.git already points at <url>

gstack-brain-restore: ~/.gstack/ has existing allowlisted files that would be clobbered

gstack-brain-restore: <url> does not look like a gstack-brain repo

database host unreachable (<code> <host>); your gbrain config is unchanged. Fix: check network or VPN, then re-run /sync-gbrain.

[memory-ingest] ERR: gbrain import accounted for N-1 of N staged page(s) ... Refusing to advance state on every run (a .claude-style project)

[memory-ingest] FAILED <path>: <error> (left un-stamped; retried next run)

[memory-ingest] re-queued <slug>: not found in gbrain source <id> after import (retried next run)

[memory-ingest] ERR: gbrain reported N failure(s) it did not attribute to a staged page ... Refusing to advance state.

[memory-ingest] quarantined <slug> (<source path>): gbrain refuses every batch that contains it (...)

[memory-ingest] reconcile: checked N, present M, re-queued K, not yet checked L (run again to continue)

[memory-ingest] reconcile: not run (...)

[memory-ingest] ERR: another memory ingest (pid <N>) is writing <state file>; not run.

[memory-ingest] ERR: could not save ingest state <path>: <error>.

[memory-ingest] kept N unattributed transcript(s) on this machine: the brain is remote (Postgres or HTTP), ...

[memory-ingest] kept N transcript page(s) for <repo> on this machine: could not register gbrain source <id> (...)

curated artifacts pushed to git, but gbrain source <id> has 0 indexed pages. Fix: gbrain sync --source <id>, then re-run /sync-gbrain

[gbrain-sync] gbrain source <id>: path unavailable (<path>); gstack skips it.

dream: skipped — the installed gbrain cannot run only the resolve_symbol_edges phase, and the full dream cycle costs about 35 minutes (LLM phases).

call graph for <source>: unknown: installed gbrain does not expose cycle_freshness

artifacts remote: restored <url> because <owner>/gstack-artifacts-<user> does not exist and <owner>/gstack-brain-<user> does

Nothing is syncing but I expect it to

22 KiB

Raw Blame History

`BRAIN_SYNC: brain repo detected: <url>`

`ARTIFACTS_SYNC: attention: ...` at skill start

`BRAIN_SYNC: push failed: auth.`

`BRAIN_SYNC: push failed: <first-line-of-error>`

`gstack: brain-sync push NOT sent — the egress receipt could not be written`

`gstack-artifacts-init: ~/.gstack/ is already a git repo pointing at: <url>`

`Remote not reachable via SSH: <url>`

`Failed to create or find '<name>'. Try --remote <url>.`

`gstack-brain-restore: ~/.gstack/.git already points at <url>`

`gstack-brain-restore: ~/.gstack/ has existing allowlisted files that would be clobbered`

`gstack-brain-restore: <url> does not look like a gstack-brain repo`

`database host unreachable (<code> <host>); your gbrain config is unchanged. Fix: check network or VPN, then re-run /sync-gbrain.`

`[memory-ingest] ERR: gbrain import accounted for N-1 of N staged page(s) ... Refusing to advance state` on every run (a `.claude`-style project)

`[memory-ingest] FAILED <path>: <error> (left un-stamped; retried next run)`

`[memory-ingest] re-queued <slug>: not found in gbrain source <id> after import (retried next run)`

`[memory-ingest] ERR: gbrain reported N failure(s) it did not attribute to a staged page ... Refusing to advance state.`

`[memory-ingest] quarantined <slug> (<source path>): gbrain refuses every batch that contains it (...)`

`[memory-ingest] reconcile: checked N, present M, re-queued K, not yet checked L (run again to continue)`

`[memory-ingest] reconcile: not run (...)`

`[memory-ingest] ERR: another memory ingest (pid <N>) is writing <state file>; not run.`

`[memory-ingest] ERR: could not save ingest state <path>: <error>.`

`[memory-ingest] kept N unattributed transcript(s) on this machine: the brain is remote (Postgres or HTTP), ...`

`[memory-ingest] kept N transcript page(s) for <repo> on this machine: could not register gbrain source <id> (...)`

`curated artifacts pushed to git, but gbrain source <id> has 0 indexed pages. Fix: gbrain sync --source <id>, then re-run /sync-gbrain`

`[gbrain-sync] gbrain source <id>: path unavailable (<path>); gstack skips it.`

`dream: skipped — the installed gbrain cannot run only the resolve_symbol_edges phase, and the full dream cycle costs about 35 minutes (LLM phases).`

`call graph for <source>: unknown: installed gbrain does not expose cycle_freshness`

`artifacts remote: restored <url> because <owner>/gstack-artifacts-<user> does not exist and <owner>/gstack-brain-<user> does`