mirror of https://github.com/rennf93/roboco.git synced 2026-08-03 07:23:24 +02:00

Files

T

4fb0059556 fix: journals/learnings never reached the RAG corpus + git-readonly slug 404s (#339 )

* fix(rag): per-index chunk floors — journals and learnings were never indexed

The global 200-char garbage floor (sized for code/doc chunks) discarded
every templated journal note and most distilled org-memory lessons,
silently: ingest returned success with zero chunks, so agent journals
and learnings were never retrievable via RAG. IndexConfig now carries a
per-type min_chunk_length (journals 40, learnings 80, others unchanged).

* fix(mcp): git-readonly tools default project_slug from the container env

Agents 404ed /api/git/status with 'Project not found: roboco' — the
tools made the LLM supply the slug and six doc examples taught a slug
that matches no registered project. The tools now fall back to the
ROBOCO_PROJECT_SLUG the orchestrator already injects, and the stale
examples are corrected.

* feat(rag): startup backfill re-ingests zero-chunk journals and learnings

Before the per-index chunk-floor fix, ingest() returned success with
chunk_count=0 for undersized content: every historical journal entry and
distilled learning below the (then-global) 200-char floor was durably
recorded in journal_entries but silently never got a chunks_journals /
chunks_learnings row, and no exception meant the existing dead-letter
(rag_index_failures) never saw it either.

Extends the startup reconcile (roboco/api/app.py _reconcile_rag_indexes)
with a new pass: backfill_unindexed_journals (roboco/services/
rag_index_failures.py) queries journal_entries for rows missing from each
vector table and re-ingests them through the same live code paths
(_reindex_journal_entry / record_learning).

Journals and learnings are backfilled independently since a LEARNING entry
can clear the (lower) JOURNALS floor while still failing the (higher)
LEARNINGS floor — a learning's doc_source is a content hash, not the entry
id, so presence there is checked by hashing each candidate the same way
LearningsIndexPlugin.record_learning does and batch-querying chunks_learnings
for those exact sources.

Bounded to 200 rows per pass per boot (converges over restarts on a larger
backlog) and best-effort per row (one failure never aborts the pass). Rows
still under the current floor are excluded by a length filter in the SELECT
so they are never retried forever, and private entries are excluded from
the JOURNALS pass exactly like the live indexing path.

* test(rag): scope backfill assertions to their own rows

---------

Co-authored-by: Renn F <rennf93@users.noreply.github.com>

2026-07-08 16:03:00 +02:00

3.1 KiB

Raw Permalink Blame History

Git Commit Workflow

Commit Format

All commits are automatically prefixed with the task ID by the choreographer:

[{task-id-prefix}] {message}

Example: [a1b2c3d4] Add rate limiting endpoint

You write the message — the prefix is added for you. Don't include [task-id] yourself; it gets stripped and re-applied.

Who Can Commit

commit is in the roboco-do MCP and is mounted only for developers and documenters. PMs delegate code work and call complete to merge.

There is no roboco_git_commit / _push / _create_pr MCP tool. The single commit verb covers commit + push + PR-trigger via the choreographer.

Creating Commits

commit(
    message="Add rate limiting endpoint",
    files=["roboco/api/routes/rate.py"],  # optional; defaults to all staged
)

This automatically:

Prefixes the commit with [task-id-first-8-chars]
Validates the message via commit_validator
Stages the listed files (or everything tracked + modified if omitted)
Commits inside your task worktree ({clone_root}/.worktrees/{task-id-first-8}/) — your cwd, never the clone root
Pushes the task's recorded branch by name (independent of whatever the clone happens to be checked out on)
Records the commit on the task (commits[] field on TaskTable)
Opens a PR through the choreographer when the task transitions out of in_progress (no separate create_pr call required)

Before Committing

Run tests: uv run pytest or pnpm test
Run linter: uv run ruff check . or pnpm lint
Run type check: uv run mypy roboco/ or pnpm typecheck
Format code: uv run ruff format . or pnpm format

Never use uv run --active or point uv at /app. Bare uv run is cwd-relative and resolves your workspace venv (symlinked into the worktree) — that's always what you want. --active retargets onto the image-baked /app/.venv (the MCP-gateway venv) and rebuilds it, bricking every tool you have. The bash-guard blocks it; if you ever feel pushed toward --active, call i_am_blocked(reason='workspace venv broken') instead. See docs/rag/architecture/workspaces.md.

After Committing

You don't push or create a PR yourself. The choreographer pushed the commit during commit(), and the PR is opened/merged as part of the lifecycle transitions:

open_pr(task_id) — opens the PR (devs)
pass(task_id) (QA) → i_documented(task_id) (doc) → complete(task_id) (cell PM merges the leaf PR). Assembled PRs pass the in-path gate first: the cell PM's submit_up (cell→root PR) and the main PM's submit_root (root→master PR) open the PR and enter awaiting_pr_review; after a reviewer pr_pass, the cell PM completes to merge cell→root, while the main PM's complete escalates the root to the CEO, who merges to master.

Viewing Commits and History

# Read-only inspection (any role) — roboco-git-readonly MCP
# project_slug is optional — omit it and your own project is used.
status = roboco_git_status()
log = roboco_git_log(branch="feature/backend/a1b2c3d4--def67890")
diff = roboco_git_diff()
branches = roboco_git_branch_list()

3.1 KiB Raw Permalink Blame History