From fc2723c39ff7cc844e9c59e88ada439af7fb5f5b Mon Sep 17 00:00:00 2001 From: Andrey Oblivantsev Date: Fri, 14 Aug 2026 15:48:26 +0100 Subject: [PATCH] feat: D24 fact intervals (--as-of) and bin/stack assistant helpers. (#37) Store valid_from/valid_to on leafs and filter search by calendar day without overloading D16 source staleness; stack start/start-assistant wires brain + PicoClaw. --- AGENTS.md | 6 + PLAN.md | 12 +- README.md | 4 + bin/kb/add | 6 + bin/stack/lib.sh | 235 +++++++++++++++++++++++++++++++ bin/stack/start | 21 +++ bin/stack/start-assistant | 15 ++ bin/stack/status | 17 +++ bin/stack/stop | 13 ++ bin/tools/kblib.py | 90 ++++++++++-- bin/tools/test_kblib.py | 32 +++++ bin/tools/test_published_docs.py | 18 +++ bin/tools/test_stack.py | 213 ++++++++++++++++++++++++++++ compose.yaml | 1 + docs/README.md | 4 +- docs/design.md | 9 ++ docs/picoclaw.md | 12 ++ docs/roadmap.md | 6 +- docs/runbook.md | 16 ++- internal/brain/db.go | 9 ++ internal/brain/http.go | 6 +- internal/brain/rank/args.go | 12 +- internal/brain/rank/asof_test.go | 34 +++++ internal/brain/rank/query.go | 6 +- internal/brain/rank/rank.go | 35 ++++- internal/brain/search.go | 44 +++++- internal/facts/interval.go | 44 ++++++ internal/facts/interval_test.go | 73 ++++++++++ internal/httpapi/mcp.go | 9 +- internal/httpapi/server.go | 14 +- internal/httpapi/server_test.go | 10 +- internal/httpapi/spec.go | 3 + skills/brain/SKILL.md | 3 + skills/picoclaw/SKILL.md | 6 + 34 files changed, 991 insertions(+), 47 deletions(-) create mode 100644 bin/stack/lib.sh create mode 100755 bin/stack/start create mode 100755 bin/stack/start-assistant create mode 100755 bin/stack/status create mode 100755 bin/stack/stop create mode 100644 bin/tools/test_stack.py create mode 100644 internal/brain/rank/asof_test.go create mode 100644 internal/facts/interval.go create mode 100644 internal/facts/interval_test.go diff --git a/AGENTS.md b/AGENTS.md index 6364d7e..60de48d 100644 --- a/AGENTS.md +++ b/AGENTS.md @@ -53,6 +53,7 @@ bin/qa/ stats.go (DuckDB quantiles / JSONL count; gcc CGO, not Zig) bin/watch/ corpus watcher (used by bin/brain/watch.go) bin/tools/ vendored python libs behind bin/* (kblib, yamlout, websearch) bin/cgo/ zig zcc zc++ (CGO via zig cc, not gcc) +bin/stack/ start start-assistant stop status (compose + PicoClaw agent) bin/docker-entrypoint container entrypoint (api: serve|search|watch; index: python) compose.yaml docker composition (root level, not docker/) Dockerfile api (Zig CGO, no Python) + index (Python write) @@ -88,6 +89,7 @@ bin/facts/audit.go ["self"|"db"|"contradict"] # 2-source + D16 adjudication bin/facts/crm.go [--dry-run] # proof person↔company/company↔project (ooCRM × corpus SoT) bin/kb/search "query" [--repo X] # deprecated wrapper → bin/brain/search.go bin/brain/search.go "query" [--root facts|info] # deduction search → YAML +bin/brain/search.go "query" --as-of 2025-01-01 # D24 fact intervals bin/brain/search.go "query" --no-web # local graph only source <(./bin/cli/complete.go bash) # flaggy completions (D23) eval "$(bin/cgo/zig env)" # Zig cc + liblbug (not gcc) @@ -98,6 +100,10 @@ bin/brain/get.go [--body] [--json] # Go read; Python bin/kb/get CI bin/brain/stats.go [--json] bin/brain/eval.go [--json] # recall@5; questions in internal/brain/rank bin/brain/serve.go # HTTP :8630; GET /openapi.json POST /mcp +bin/stack/start # brain HTTP/MCP (reuse healthy :8630) +bin/stack/start-assistant # + reasoner + PicoClaw agent +bin/stack/status # YAML health +bin/stack/stop # compose stop; volumes kept bin/markdown/import.go [dir] # H2 leafs → YAML; Python bin/md/import fallback bin/git/import.go [REPO] [--json] [--limit N] # go-git history → commit leafs bin/web/search.go "query" [--json] # SearXNG; throttled ≠ absence diff --git a/PLAN.md b/PLAN.md index 1336909..c98a7f0 100644 --- a/PLAN.md +++ b/PLAN.md @@ -9,7 +9,8 @@ v2 board: milestone [v2](https://git.produktor.io/eSlider/2dph/milestone/13) — OCR [#6](https://git.produktor.io/eSlider/2dph/issues/6) in, [#29](https://git.produktor.io/eSlider/2dph/issues/29) OQ1 in, [#30](https://git.produktor.io/eSlider/2dph/issues/30) OQ3 in, -[#34](https://git.produktor.io/eSlider/2dph/issues/34) D23 in. +[#34](https://git.produktor.io/eSlider/2dph/issues/34) D23 in, +[#36](https://git.produktor.io/eSlider/2dph/issues/36) OQ5/D24 in. Gap: [docs/roadmap.md](docs/roadmap.md). ## What @@ -53,6 +54,7 @@ detective method: **a fact needs ≥2 independent sources or it is | D21 | CGO | Ladybug/tokenizers CGO is compiled with **Zig** (`bin/cgo/zcc` → `zig cc -target …-linux-gnu`), not gcc. `bin/cgo/zig` pins Zig 0.14.1 + liblbug 0.19.1 + libtokenizers 1.27.0. Compose `target: api` has no CPython; write/rebuild is profile `index`. | | D22 | analytics | **duckdb-go** in-process (`internal/duckstats`, `bin/qa/stats.go`) for quantiles/JSONL. Links with **gcc/g++**, not Zig. Ladybug stays the graph; web-search cache stays modernc sqlite. Slice small structured docs with **mikefarah/yq**, not kislyuk/jq. [#30](https://git.produktor.io/eSlider/2dph/issues/30). | | D23 | CLI | **flaggy** (`github.com/integrii/flaggy`, 0 deps). Flags at any position. Wrapper `internal/cli`. Bash complete: `source <(./bin/cli/complete.go bash)`. No cobra, no stdlib `flag` in Go tools. Search does not intercept the word `completion`. [#34](https://git.produktor.io/eSlider/2dph/issues/34). | +| D24 | fact intervals | Leaf `valid_from` / `valid_to` (YYYY-MM-DD, inclusive; empty = open/legacy). Search `--as-of` / MCP `as_of` keeps facts active that day. Not D16 `temporal_freshness` (source stale vs HEAD). Empty interval = always visible. [#36](https://git.produktor.io/eSlider/2dph/issues/36). | ## Architecture @@ -83,7 +85,8 @@ detective method: **a fact needs ≥2 independent sources or it is (libs in internal/chats; no chats index) mail/ocr.go tesseract eng+deu (pdftoppm scans) md/import (deprecated; bin/markdown/import.go) - brain/extract brain/audit brain/deduce (thinking wrapper) + brain/extract brain/audit brain/deduce (thinking wrapper) + stack/start start-assistant stop status web/search (deprecated shim → web/search.go) db/psql-yq (vendored) ssh-tunnel onlyoffice pg tunnel 5433 @@ -101,7 +104,8 @@ them from each hit (1=File, 2=Commit, 3=Person). Rebuild writes `Leaf-[:FROM_FILE]->File`; git import writes the rest. Common props on every node/edge: `root`, `confidence`, `evidence[]`, `how`, -`where`, `when`, `source_rev`. +`where`, `when`, `source_rev`. Leaf interval of truth (D24): `valid_from`, +`valid_to`. ## Config @@ -132,6 +136,8 @@ Common props on every node/edge: `root`, `confidence`, `evidence[]`, `how`, quantiles / JSONL count. Not a second graph. [#30](https://git.produktor.io/eSlider/2dph/issues/30). - OQ4: YAML-first storage for leafs — deferred: JSON is ~10x faster to serialize and unambiguous; YAML only where humans edit files. +- OQ5: **in** — fact `valid_from` / `valid_to` + `--as-of` / MCP `as_of` (D24). + Not D16 `temporal_freshness`. [#36](https://git.produktor.io/eSlider/2dph/issues/36). ## Mail pipeline (done) diff --git a/README.md b/README.md index fa01fb7..c7b55b9 100644 --- a/README.md +++ b/README.md @@ -160,6 +160,10 @@ go test ./... && uv run python -m unittest discover -s bin/tools -t . Docker (optional, cached model + var volumes): ```bash +bin/stack/start # brain HTTP/MCP :8630 +bin/stack/start-assistant # + qwen3.5:9b + PicoClaw agent +bin/stack/status +bin/stack/stop docker compose up -d brain # API (Zig CGO serve :8630) docker compose --profile index run --rm index # Python Ladybug rebuild docker compose --profile picoclaw up brain-mcp # MCP on 127.0.0.1:8630 diff --git a/bin/kb/add b/bin/kb/add index 14aa0d8..7cb4446 100755 --- a/bin/kb/add +++ b/bin/kb/add @@ -65,6 +65,10 @@ def main(argv: list[str]) -> int: p.add_argument("--how", default="brain/add") p.add_argument("--loc", default="") p.add_argument("--type", default="reference", dest="type_") + p.add_argument("--valid-from", default="", dest="valid_from", + help="fact interval start YYYY-MM-DD (D24)") + p.add_argument("--valid-to", default="", dest="valid_to", + help="fact interval end YYYY-MM-DD inclusive; empty=open (D24)") args = p.parse_args(argv) if args.json: @@ -86,6 +90,8 @@ def main(argv: list[str]) -> int: "how": args.how, "loc": args.loc or args.source, "type": args.type_, + "valid_from": args.valid_from, + "valid_to": args.valid_to, }] for lf in leafs: diff --git a/bin/stack/lib.sh b/bin/stack/lib.sh new file mode 100644 index 0000000..8db3a52 --- /dev/null +++ b/bin/stack/lib.sh @@ -0,0 +1,235 @@ +# bin/stack/lib.sh — compose helpers for start / start-assistant / stop / status. +# Sourced, not executed. No secrets. No host-absolute paths. + +BRAIN_URL="${BRAIN_URL:-http://127.0.0.1:8630}" +REASONER_URL="${REASONER_URL:-http://127.0.0.1:11435}" +PICOCLAW_URL="${PICOCLAW_URL:-http://127.0.0.1:18790}" +REASONER_MODEL="${REASONER_MODEL:-qwen3.5:9b}" +STACK_WAIT_SECS="${STACK_WAIT_SECS:-90}" +STACK_WAIT_INTERVAL="${STACK_WAIT_INTERVAL:-2}" +STACK_PULL_SECS="${STACK_PULL_SECS:-600}" + +if [[ -z "${ROOT:-}" ]]; then + STACK_DIR="$(CDPATH= cd -- "$(dirname "${BASH_SOURCE[0]}")" && pwd)" + ROOT="$(CDPATH= cd -- "$STACK_DIR/../.." && pwd)" +fi + +stack_usage() { + awk 'NR == 1 { next } /^#/ { sub(/^# ?/, ""); print; next } { exit }' "$1" +} + +stack_die() { + echo "bin/stack: $*" >&2 + return 1 +} + +compose() { + docker compose -f "$ROOT/compose.yaml" --project-directory "$ROOT" "$@" +} + +http_get() { + local url=$1 + local timeout=${2:-5} + curl -sS --max-time "$timeout" "$url" 2>/dev/null || return 1 +} + +health_ok() { + local url=$1 + local timeout=${2:-5} + local body + body=$(http_get "$url" "$timeout") || return 1 + printf '%s' "$body" | grep -q '"status":"ok"' +} + +wait_health() { + local url=$1 + local n=0 + while ((n <= STACK_WAIT_SECS)); do + if health_ok "$url"; then + return 0 + fi + n=$((n + 1)) + if ((n <= STACK_WAIT_SECS)); then + sleep "$STACK_WAIT_INTERVAL" + fi + done + return 1 +} + +wait_http() { + local url=$1 + local n=0 + while ((n <= STACK_WAIT_SECS)); do + if http_get "$url" 5 >/dev/null; then + return 0 + fi + n=$((n + 1)) + if ((n <= STACK_WAIT_SECS)); then + sleep "$STACK_WAIT_INTERVAL" + fi + done + return 1 +} + +mcp_body() { + curl -sS --max-time 10 \ + -H 'Content-Type: application/json' \ + -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}' \ + "$BRAIN_URL/mcp" 2>/dev/null || return 1 +} + +mcp_ok() { + local body + body=$(mcp_body) || return 1 + printf '%s' "$body" | grep -Eq '"name": ?"search"' || return 1 + printf '%s' "$body" | grep -Eq '"name": ?"get"' || return 1 + printf '%s' "$body" | grep -Eq '"name": ?"audit"' || return 1 + return 0 +} + +reasoner_tags() { + http_get "$REASONER_URL/api/tags" 5 +} + +reasoner_has_model() { + local body + body=$(reasoner_tags) || return 1 + printf '%s' "$body" | grep -Fq "$REASONER_MODEL" +} + +ensure_mcp() { + mcp_ok || stack_die "MCP tools/list missing search/get/audit at $BRAIN_URL/mcp" +} + +ensure_brain() { + if health_ok "$BRAIN_URL/health"; then + echo "brain: reuse $BRAIN_URL" >&2 + else + echo "brain: compose up" >&2 + compose up -d brain + wait_health "$BRAIN_URL/health" || stack_die "brain health failed at $BRAIN_URL/health" + fi + ensure_mcp +} + +pull_reasoner_model() { + echo "reasoner: pulling $REASONER_MODEL (CPU, may take minutes)" >&2 + curl -sS --max-time "$STACK_PULL_SECS" \ + -H 'Content-Type: application/json' \ + -d "{\"name\":\"$REASONER_MODEL\"}" \ + "$REASONER_URL/api/pull" >/dev/null +} + +ensure_reasoner() { + if reasoner_has_model; then + echo "reasoner: reuse $REASONER_URL model $REASONER_MODEL" >&2 + return 0 + fi + if ! reasoner_tags >/dev/null; then + echo "reasoner: compose up" >&2 + compose --profile reasoner up -d reasoner + wait_http "$REASONER_URL/api/tags" || stack_die "reasoner not listening at $REASONER_URL" + fi + if reasoner_has_model; then + return 0 + fi + pull_reasoner_model + reasoner_has_model || stack_die "reasoner missing model $REASONER_MODEL" +} + +ensure_picoclaw() { + echo "picoclaw: compose up --no-deps (reuse healthy :8630/:11435)" >&2 + compose --profile picoclaw up -d --no-deps picoclaw + wait_health "$PICOCLAW_URL/health" || stack_die "picoclaw health failed at $PICOCLAW_URL/health" +} + +stack_status() { + local bh=down mcp=down ph=down present=false + health_ok "$BRAIN_URL/health" && bh=ok + mcp_ok && mcp=ok + reasoner_has_model && present=true + health_ok "$PICOCLAW_URL/health" && ph=ok + cat <&2 + echo " $ROOT/bin/stack/start-assistant" >&2 + echo " docker compose --profile picoclaw exec -it picoclaw picoclaw agent" >&2 + return 0 + fi + echo "picoclaw: agent (search → get → audit before a factual reply)" >&2 + exec docker compose -f "$ROOT/compose.yaml" --project-directory "$ROOT" \ + --profile picoclaw exec "${opts[@]}" picoclaw picoclaw agent "$@" +} + +stack_start_assistant() { + local attach=1 + local agent_args=() + while (($#)); do + case "$1" in + -h | --help) + stack_usage "$ROOT/bin/stack/start-assistant" + return 0 + ;; + --no-attach) + attach=0 + shift + ;; + --) + shift + agent_args+=("$@") + break + ;; + *) + agent_args+=("$1") + shift + ;; + esac + done + stack_start + ensure_reasoner + ensure_picoclaw + stack_status + if ((attach == 0)); then + echo "picoclaw: gateway $PICOCLAW_URL (agent not attached)" >&2 + echo "ask the brain: $ROOT/bin/stack/start-assistant" >&2 + echo "one-shot: $ROOT/bin/stack/start-assistant -- -m \"search the 2dph brain for LadybugDB\"" >&2 + return 0 + fi + stack_attach_agent "${agent_args[@]}" +} + +stack_stop() { + case "${1:-}" in + -h | --help) + stack_usage "$ROOT/bin/stack/stop" + return 0 + ;; + esac + echo "stack: stop brain brain-mcp reasoner picoclaw (volumes kept)" >&2 + compose --profile picoclaw --profile reasoner stop picoclaw brain-mcp reasoner brain +} diff --git a/bin/stack/start b/bin/stack/start new file mode 100755 index 0000000..37f25a9 --- /dev/null +++ b/bin/stack/start @@ -0,0 +1,21 @@ +#!/usr/bin/env bash +# bin/stack/start - bring up brain HTTP/MCP and wait until search/get/audit respond. +# +# bin/stack/start +# bin/stack/status +# +# Reuses a healthy process on :8630 (host serve or compose). Does not start +# PicoClaw. Does not rebuild Ladybug. +set -euo pipefail + +STACK_DIR="$(CDPATH= cd -- "$(dirname "$0")" && pwd)" +# shellcheck source=lib.sh +source "$STACK_DIR/lib.sh" +case "${1:-}" in +-h | --help) + stack_usage "$0" + exit 0 + ;; +esac +stack_start "$@" +stack_status diff --git a/bin/stack/start-assistant b/bin/stack/start-assistant new file mode 100755 index 0000000..323219f --- /dev/null +++ b/bin/stack/start-assistant @@ -0,0 +1,15 @@ +#!/usr/bin/env bash +# bin/stack/start-assistant - start + CPU reasoner + PicoClaw, then attach agent. +# +# bin/stack/start-assistant +# bin/stack/start-assistant --no-attach +# bin/stack/start-assistant -- -m "search the 2dph brain for LadybugDB" +# +# Pulls qwen3.5:9b if missing. Gateway :18790. Agent uses MCP search → get → audit. +# --no-attach leaves the gateway up without exec. +set -euo pipefail + +STACK_DIR="$(CDPATH= cd -- "$(dirname "$0")" && pwd)" +# shellcheck source=lib.sh +source "$STACK_DIR/lib.sh" +stack_start_assistant "$@" diff --git a/bin/stack/status b/bin/stack/status new file mode 100755 index 0000000..eca5428 --- /dev/null +++ b/bin/stack/status @@ -0,0 +1,17 @@ +#!/usr/bin/env bash +# bin/stack/status - YAML health for brain MCP, reasoner model, PicoClaw gateway. +# +# bin/stack/status +# bin/stack/status | yq '.picoclaw' +set -euo pipefail + +STACK_DIR="$(CDPATH= cd -- "$(dirname "$0")" && pwd)" +# shellcheck source=lib.sh +source "$STACK_DIR/lib.sh" +case "${1:-}" in +-h | --help) + stack_usage "$0" + exit 0 + ;; +esac +stack_status diff --git a/bin/stack/stop b/bin/stack/stop new file mode 100755 index 0000000..880c419 --- /dev/null +++ b/bin/stack/stop @@ -0,0 +1,13 @@ +#!/usr/bin/env bash +# bin/stack/stop - stop compose brain / brain-mcp / reasoner / picoclaw. +# +# bin/stack/stop +# +# Volumes kept (kb, reasoner weights, picoclaw-home). Does not kill a host +# bin/brain/serve.go that is not a compose service. +set -euo pipefail + +STACK_DIR="$(CDPATH= cd -- "$(dirname "$0")" && pwd)" +# shellcheck source=lib.sh +source "$STACK_DIR/lib.sh" +stack_stop "$@" diff --git a/bin/tools/kblib.py b/bin/tools/kblib.py index 85febd5..3afd094 100644 --- a/bin/tools/kblib.py +++ b/bin/tools/kblib.py @@ -62,7 +62,9 @@ def init_schema(conn: ladybug.Connection) -> None: "CREATE NODE TABLE IF NOT EXISTS Leaf (" " id STRING, text STRING, root STRING, confidence STRING, " " sha256 STRING, source STRING, source_rev STRING, observed_at STRING, " - " how STRING, loc STRING, type STRING, embedding FLOAT[256], " + " how STRING, loc STRING, type STRING, " + " valid_from STRING, valid_to STRING, " + " embedding FLOAT[256], " " PRIMARY KEY(id))" ) conn.execute( @@ -91,6 +93,46 @@ def init_schema(conn: ladybug.Connection) -> None: conn.execute( "CREATE REL TABLE IF NOT EXISTS AUTHORED (FROM Commit TO Person)" ) + ensure_interval_columns(conn) + + +def ensure_interval_columns(conn: ladybug.Connection) -> None: + """D24: add valid_from/valid_to on older Leaf tables (idempotent ALTER).""" + for col in ("valid_from", "valid_to"): + try: + conn.execute(f"ALTER TABLE Leaf ADD {col} STRING") + except Exception: + pass + + +def normalize_day(s: str) -> str: + s = (s or "").strip() + if len(s) >= 10 and s[4] == "-" and s[7] == "-": + return s[:10] + return s + + +def active_at(valid_from: str, valid_to: str, as_of: str) -> bool: + """D24: fact interval of truth. Empty ends = always; empty as_of = no filter.""" + as_of = normalize_day(as_of) + if not as_of: + return True + fro = normalize_day(valid_from) + to = normalize_day(valid_to) + if fro and as_of < fro: + return False + if to and as_of > to: + return False + return True + + +def filter_as_of(hits: list[dict], as_of: str) -> list[dict]: + if not as_of: + return hits + return [ + h for h in hits + if active_at(str(h.get("valid_from") or ""), str(h.get("valid_to") or ""), as_of) + ] def leaf_id(text: str, source: str) -> str: @@ -99,19 +141,24 @@ def leaf_id(text: str, source: str) -> str: def upsert_leaf(conn: ladybug.Connection, *, text: str, root: str, confidence: str, source: str, source_rev: str, how: str, loc: str, type_: str, - embedding: list[float] | None) -> str: + embedding: list[float] | None, + valid_from: str = "", valid_to: str = "") -> str: lid = leaf_id(text, source) obs = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()) + vf = normalize_day(valid_from) + vt = normalize_day(valid_to) conn.execute( "MERGE (l:Leaf {id:$id}) " "SET l.text=$text, l.root=$root, l.confidence=$confidence, " " l.sha256=$sha, l.source=$source, l.source_rev=$rev, l.observed_at=$obs, " - " l.how=$how, l.loc=$location, l.type=$type" + " l.how=$how, l.loc=$location, l.type=$type, " + " l.valid_from=$vf, l.valid_to=$vt" + (", l.embedding=$emb" if embedding else ""), parameters={ "id": lid, "text": text, "root": root, "confidence": confidence, "sha": sha256_b64(text), "source": source, "rev": source_rev, "obs": obs, "how": how, "location": loc, "type": type_, + "vf": vf, "vt": vt, "emb": (embedding if embedding else None), }, ) @@ -121,9 +168,10 @@ def upsert_leaf(conn: ladybug.Connection, *, text: str, root: str, confidence: s def add_leafs(conn: ladybug.Connection, leafs: list[dict]) -> list[str]: """Write facts+info leafs in one transaction. Safe while FTS/HNSW exist. - Each leaf dict: text, source, optional root/confidence/source_rev/how/loc/type/embedding. - Does not delete the database file. Measured on Ladybug 0.19: MERGE of new - ids (and updates) stays FTS+HNSW queryable; DROP INDEX is the fatal path. + Each leaf dict: text, source, optional root/confidence/source_rev/how/loc/type/ + embedding/valid_from/valid_to. Does not delete the database file. Measured on + Ladybug 0.19: MERGE of new ids (and updates) stays FTS+HNSW queryable; DROP + INDEX is the fatal path. """ if not leafs: return [] @@ -148,6 +196,8 @@ def add_leafs(conn: ladybug.Connection, leafs: list[dict]) -> list[str]: loc=str(lf.get("loc") or lf.get("source") or ""), type_=str(lf.get("type") or lf.get("type_") or "reference"), embedding=lf.get("embedding"), + valid_from=str(lf.get("valid_from") or ""), + valid_to=str(lf.get("valid_to") or ""), ) ) if started: @@ -285,29 +335,39 @@ def drop_indexes(conn: ladybug.Connection) -> None: def query_fts(conn: ladybug.Connection, text: str, limit: int = 10) -> list[dict]: r = conn.execute( "CALL QUERY_FTS_INDEX('Leaf', 'id', $q) " - "RETURN node.id, node.text, node.root, score ORDER BY score DESC LIMIT $n", + "RETURN node.id, node.text, node.root, score, node.valid_from, node.valid_to " + "ORDER BY score DESC LIMIT $n", parameters={"q": text, "n": limit}, ) - return [{"id": row[0], "text": row[1], "root": row[2], "score": row[3]} for row in r.get_all()] + return [ + { + "id": row[0], "text": row[1], "root": row[2], "score": row[3], + "valid_from": row[4] or "", "valid_to": row[5] or "", + } + for row in r.get_all() + ] def query_vector(conn: ladybug.Connection, embedding: list[float], limit: int = 10) -> list[dict]: r = conn.execute( "CALL QUERY_VECTOR_INDEX('Leaf', 'Leaf_vec', $q, $n) " - "RETURN node.id, node.text, node.root, distance ORDER BY distance LIMIT $n", + "RETURN node.id, node.text, node.root, distance, node.valid_from, node.valid_to " + "ORDER BY distance LIMIT $n", parameters={"q": embedding, "n": limit}, ) out = [] for row in r.get_all(): - # distance -> similarity reasonable for cosine score = 1.0 - row[3] if row[3] is not None else 0.0 - out.append({"id": row[0], "text": row[1], "root": row[2], "score": score}) + out.append({ + "id": row[0], "text": row[1], "root": row[2], "score": score, + "valid_from": row[4] or "", "valid_to": row[5] or "", + }) return out def hybrid_search(conn: ladybug.Connection, embedding: list[float], fts_hits: list[dict], - limit: int = 10) -> list[dict]: - """Merge FTS + vector by reciprocal rank fusion.""" + limit: int = 10, as_of: str = "") -> list[dict]: + """Merge FTS + vector by reciprocal rank fusion; optional D24 as-of filter.""" fused: dict[str, dict] = {} for rank, hit in enumerate(fts_hits): fused.setdefault(hit["id"], {**hit, "rrf": 0.0})["rrf"] = 1.0 / (60 + rank + 1) @@ -315,8 +375,10 @@ def hybrid_search(conn: ladybug.Connection, embedding: list[float], fts_hits: li entry = fused.setdefault(hit["id"], {**hit, "rrf": 0.0}) entry["rrf"] += 1.0 / (60 + rank + 1) entry.setdefault("score", hit.get("score", 0.0)) + entry.setdefault("valid_from", hit.get("valid_from") or "") + entry.setdefault("valid_to", hit.get("valid_to") or "") ranked = sorted(fused.values(), key=lambda h: h.get("rrf", 0.0), reverse=True) - return ranked[:limit] + return filter_as_of(ranked, as_of)[:limit] def stats(conn: ladybug.Connection) -> dict: diff --git a/bin/tools/test_kblib.py b/bin/tools/test_kblib.py index 140bd96..1b5c002 100644 --- a/bin/tools/test_kblib.py +++ b/bin/tools/test_kblib.py @@ -194,6 +194,38 @@ class KblibTest(unittest.TestCase): self.assertEqual(person["name"], "Ada Lovelace") self.assertEqual(person["depth"], 3) + def test_as_of_keeps_x_drops_y(self) -> None: + """OQ5/#36: as of 2025-01-01 → works-at-X, not works-at-Y.""" + kblib.upsert_leaf( + self.conn, text="Andrey works at X", root="facts", + confidence="confirmed", source="crm.md x contract.md", + source_rev="r1", how="test", loc="/tmp", type_="fact", + embedding=make_emb(0.5), + valid_from="2024-03-01", valid_to="2025-07-15", + ) + kblib.upsert_leaf( + self.conn, text="Andrey works at Y", root="facts", + confidence="confirmed", source="offer.md x payroll.md", + source_rev="r1", how="test", loc="/tmp", type_="fact", + embedding=make_emb(0.6), + valid_from="2025-07-16", valid_to="", + ) + kblib.ensure_indexes(self.conn) + hits = kblib.query_fts(self.conn, "Andrey works", 10) + kept = kblib.filter_as_of(hits, "2025-01-01") + texts = [h["text"] for h in kept] + self.assertTrue(any("works at X" in t for t in texts), texts) + self.assertFalse(any("works at Y" in t for t in texts), texts) + later = kblib.filter_as_of(hits, "2025-08-01") + later_texts = [h["text"] for h in later] + self.assertTrue(any("works at Y" in t for t in later_texts), later_texts) + self.assertFalse(any("works at X" in t for t in later_texts), later_texts) + + def test_active_at_pure(self) -> None: + self.assertTrue(kblib.active_at("2024-03-01", "2025-07-15", "2025-01-01")) + self.assertFalse(kblib.active_at("2025-07-16", "", "2025-01-01")) + self.assertTrue(kblib.active_at("", "", "2025-01-01")) + if __name__ == "__main__": unittest.main() diff --git a/bin/tools/test_published_docs.py b/bin/tools/test_published_docs.py index 536a3ae..d74761b 100644 --- a/bin/tools/test_published_docs.py +++ b/bin/tools/test_published_docs.py @@ -186,3 +186,21 @@ class PublishedDocsTest(unittest.TestCase): self.assertIn("epic #16", index) agents = (ROOT / "AGENTS.md").read_text() self.assertIn("roadmap.md", agents) + + def test_oq5_intervals_are_not_d16_stale(self) -> None: + plan = (ROOT / "PLAN.md").read_text() + design = (ROOT / "docs" / "design.md").read_text() + road = (ROOT / "docs" / "roadmap.md").read_text() + contradict = (ROOT / "internal" / "facts" / "contradict.go").read_text() + interval = (ROOT / "internal" / "facts" / "interval.go").read_text() + self.assertIn("OQ5", plan) + self.assertIn("D24", plan) + self.assertIn("issues/36", plan) + self.assertIn("valid_from", plan) + self.assertIn("--as-of", design) + self.assertIn("issues/36", road) + self.assertIn("**in**", road[road.index("OQ5"):road.index("OQ5") + 80]) + self.assertIn("temporal_freshness", contradict) + self.assertNotIn("valid_from", contradict) + self.assertIn("ActiveAt", interval) + self.assertIn("NormalizeDay", interval) diff --git a/bin/tools/test_stack.py b/bin/tools/test_stack.py new file mode 100644 index 0000000..6ad25ba --- /dev/null +++ b/bin/tools/test_stack.py @@ -0,0 +1,213 @@ +"""bin/stack/{start,start-assistant,stop,status} — offline contract + fake PATH.""" +from __future__ import annotations + +import os +import stat +import subprocess +import tempfile +import unittest +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[2] +METHODS = ("start", "start-assistant", "stop", "status") + + +class StackLayoutTest(unittest.TestCase): + def test_methods_are_bash_with_usage_comment(self) -> None: + lib = ROOT / "bin" / "stack" / "lib.sh" + self.assertTrue(lib.is_file(), "missing bin/stack/lib.sh") + for name in METHODS: + p = ROOT / "bin" / "stack" / name + self.assertTrue(p.is_file(), f"missing bin/stack/{name}") + self.assertTrue(os.access(p, os.X_OK), f"bin/stack/{name} must be executable") + lines = p.read_text().splitlines() + self.assertEqual(lines[0], "#!/usr/bin/env bash", name) + self.assertTrue(lines[1].startswith("# bin/stack/"), name) + text = "\n".join(lines) + self.assertIn("lib.sh", text, name) + self.assertNotIn("/mnt/", text, name) + self.assertNotIn("/home/", text, name) + + def test_lib_has_no_host_paths_or_secrets(self) -> None: + lib = (ROOT / "bin" / "stack" / "lib.sh").read_text() + self.assertIn("stack_start", lib) + self.assertIn("stack_start_assistant", lib) + self.assertIn("stack_stop", lib) + self.assertIn("stack_status", lib) + self.assertIn("qwen3.5:9b", lib) + self.assertIn("picoclaw agent", lib) + self.assertIn("--no-deps", lib) + self.assertIn("tools/list", lib) + self.assertNotIn("/mnt/", lib) + self.assertNotIn("/home/", lib) + self.assertNotIn("password", lib.lower()) + self.assertNotIn("GITEA_TOKEN", lib) + + def test_start_does_not_launch_picoclaw(self) -> None: + start = (ROOT / "bin" / "stack" / "start").read_text() + self.assertIn("stack_start", start) + self.assertNotIn("stack_start_assistant", start) + self.assertNotIn("picoclaw agent", start) + + def test_start_assistant_attaches_agent(self) -> None: + src = (ROOT / "bin" / "stack" / "start-assistant").read_text() + self.assertIn("stack_start_assistant", src) + self.assertIn("--no-attach", src) + + def test_stop_does_not_down_volumes(self) -> None: + lib = (ROOT / "bin" / "stack" / "lib.sh").read_text() + self.assertIn(" compose ", lib) + self.assertRegex(lib, r"\bstop\b") + self.assertNotIn(" compose down", lib) + self.assertNotIn("compose down", lib) + + def test_docs_name_stack_commands(self) -> None: + runbook = (ROOT / "docs" / "runbook.md").read_text() + pico = (ROOT / "docs" / "picoclaw.md").read_text() + agents = (ROOT / "AGENTS.md").read_text() + for text in (runbook, pico, agents): + self.assertIn("bin/stack/start", text) + self.assertIn("bin/stack/start-assistant", text) + self.assertIn("bin/stack/status", text) + self.assertIn("bin/stack/stop", text) + + + def test_help_prints_comments_not_source(self) -> None: + r = subprocess.run( + [str(ROOT / "bin" / "stack" / "start"), "--help"], + cwd=str(ROOT), + capture_output=True, + text=True, + check=False, + ) + self.assertEqual(r.returncode, 0, r.stderr) + self.assertIn("bin/stack/start", r.stdout) + self.assertNotIn("set -euo pipefail", r.stdout) + self.assertNotIn("source ", r.stdout) + + +class StackFakePathTest(unittest.TestCase): + def _fake_bin(self, tmp: Path, *, health_ok: bool) -> Path: + bindir = tmp / "bin" + bindir.mkdir() + curl = bindir / "curl" + docker = bindir / "docker" + log = tmp / "docker.log" + curl.write_text( + f"""#!/usr/bin/env bash +url="" +for a in "$@"; do + case "$a" in http*) url=$a ;; + esac +done +if [ "{int(health_ok)}" = "0" ] && [[ "$url" == */health ]]; then + echo '{{"status":"down"}}' + exit 7 +fi +case "$url" in + */mcp) + echo '{{"jsonrpc":"2.0","id":1,"result":{{"tools":[{{"name":"search"}},{{"name":"get"}},{{"name":"audit"}}]}}}}' + ;; + */api/tags) + echo '{{"models":[{{"name":"qwen3.5:9b"}}]}}' + ;; + */api/pull) + echo '{{"status":"success"}}' + ;; + *) + echo '{{"status":"ok"}}' + ;; +esac +""" + ) + docker.write_text( + f"""#!/usr/bin/env bash +echo "$*" >> "{log}" +exit 0 +""" + ) + curl.chmod(curl.stat().st_mode | stat.S_IEXEC) + docker.chmod(docker.stat().st_mode | stat.S_IEXEC) + return bindir + + def _env(self, bindir: Path) -> dict[str, str]: + env = os.environ.copy() + env["PATH"] = f"{bindir}:{env.get('PATH', '')}" + env["STACK_WAIT_SECS"] = "1" + env["STACK_WAIT_INTERVAL"] = "0" + return env + + def test_start_skips_compose_when_brain_healthy(self) -> None: + with tempfile.TemporaryDirectory() as raw: + tmp = Path(raw) + bindir = self._fake_bin(tmp, health_ok=True) + log = tmp / "docker.log" + r = subprocess.run( + [str(ROOT / "bin" / "stack" / "start")], + cwd=str(ROOT), + env=self._env(bindir), + capture_output=True, + text=True, + check=False, + ) + self.assertEqual(r.returncode, 0, r.stderr) + self.assertFalse(log.exists(), "healthy brain must not docker compose up") + + def test_start_ups_brain_when_unhealthy(self) -> None: + with tempfile.TemporaryDirectory() as raw: + tmp = Path(raw) + bindir = self._fake_bin(tmp, health_ok=False) + log = tmp / "docker.log" + r = subprocess.run( + [str(ROOT / "bin" / "stack" / "start")], + cwd=str(ROOT), + env=self._env(bindir), + capture_output=True, + text=True, + check=False, + ) + self.assertNotEqual(r.returncode, 0, "unhealthy brain without recovering compose must fail") + self.assertTrue(log.exists(), r.stderr) + logged = log.read_text() + self.assertIn("up -d", logged) + self.assertIn("brain", logged) + self.assertNotIn("picoclaw", logged) + + def test_stop_stops_named_services(self) -> None: + with tempfile.TemporaryDirectory() as raw: + tmp = Path(raw) + bindir = self._fake_bin(tmp, health_ok=True) + log = tmp / "docker.log" + r = subprocess.run( + [str(ROOT / "bin" / "stack" / "stop")], + cwd=str(ROOT), + env=self._env(bindir), + capture_output=True, + text=True, + check=False, + ) + self.assertEqual(r.returncode, 0, r.stderr) + logged = log.read_text() + self.assertIn("stop", logged) + self.assertNotIn(" down", logged) + for svc in ("brain", "brain-mcp", "reasoner", "picoclaw"): + self.assertIn(svc, logged) + + def test_start_assistant_no_attach_starts_picoclaw(self) -> None: + with tempfile.TemporaryDirectory() as raw: + tmp = Path(raw) + bindir = self._fake_bin(tmp, health_ok=True) + log = tmp / "docker.log" + r = subprocess.run( + [str(ROOT / "bin" / "stack" / "start-assistant"), "--no-attach"], + cwd=str(ROOT), + env=self._env(bindir), + capture_output=True, + text=True, + check=False, + ) + self.assertEqual(r.returncode, 0, r.stderr + r.stdout) + logged = log.read_text() if log.exists() else "" + self.assertIn("picoclaw", logged) + self.assertIn("--no-deps", logged) + self.assertNotIn("picoclaw agent", logged) diff --git a/compose.yaml b/compose.yaml index 4d1b3d0..19475cc 100644 --- a/compose.yaml +++ b/compose.yaml @@ -1,5 +1,6 @@ # 2dph — docker composition # +# bin/stack/start / start-assistant / status / stop # docker compose up -d brain # API (Zig CGO serve) # docker compose --profile index run --rm index # Python rebuild # docker compose --profile picoclaw up -d # brain-mcp + CPU reasoner + PicoClaw gateway diff --git a/docs/README.md b/docs/README.md index 6a8e18f..1903e31 100644 --- a/docs/README.md +++ b/docs/README.md @@ -18,9 +18,9 @@ Evidence-first knowledge graph. Facts need proof or they are | tutorial / howto | [runbook](runbook.md) — run anywhere (uv, Go, Docker) | | explanation | [design](design.md) — two roots, deduction, D17/D20/D18 | | explanation | [roadmap](roadmap.md) — gap to v1 (epic #16) | -| howto | [picoclaw](picoclaw.md) — MCP agent profile | +| howto | [picoclaw](picoclaw.md) — MCP agent (`bin/stack/start-assistant`) | | howto | [reasoner](reasoner.md) — CPU bake-off (D18) | -| reference | [PLAN.md](../PLAN.md) — decisions D1–D22 | +| reference | [PLAN.md](../PLAN.md) — decisions D1–D24 | Decisions the public face must name: **D3** SearXNG compose, **D6** Go service / Python write sidecar, **D14** `bin/{subject}/{method}.go`, **D15** Gitea origin, diff --git a/docs/design.md b/docs/design.md index 65da0d8..511cd9b 100644 --- a/docs/design.md +++ b/docs/design.md @@ -68,6 +68,15 @@ binary); conversion prints leafs, brain write is `bin/brain/index.go`. `bin/facts/audit stale` flags leafs whose observed revision is behind the corpus HEAD. +Fact **interval of truth** (D24 / OQ5): leaf props `valid_from` / +`valid_to` (YYYY-MM-DD, inclusive; empty end = open; both empty = legacy +always-active). `bin/brain/search.go --as-of YYYY-MM-DD` and MCP/HTTP +`as_of` keep hits whose interval covers that day. This is not D16 +`temporal_freshness` (source freshness vs HEAD). [#36](https://git.produktor.io/eSlider/2dph/issues/36). +Existing `kb.lbug` without the columns: open/search/add runs an idempotent +`ALTER TABLE Leaf ADD …` (no full rebuild required). Fresh `--rebuild` still +creates them in `CREATE NODE TABLE`. + ## Sources (auto-pairing) - A: runtime state — `docker ps` (container running), ports actually bound diff --git a/docs/picoclaw.md b/docs/picoclaw.md index 91f77d0..247f626 100644 --- a/docs/picoclaw.md +++ b/docs/picoclaw.md @@ -6,6 +6,18 @@ CPU reasoner. Default agent model is `qwen3.5:9b` (RAM path, D18). Weights stay in the reasoner volume, not in the 2dph image. No secrets in git: Ollama needs no key; MCP is local HTTP. +```bash +bin/stack/start-assistant +bin/stack/start-assistant --no-attach +bin/stack/start-assistant -- -m "search the 2dph brain for LadybugDB" +bin/stack/status +bin/stack/stop +``` + +`start-assistant` reuses a healthy brain on `:8630`, starts the CPU reasoner, +pulls `qwen3.5:9b` if missing, brings up the gateway with `--no-deps picoclaw`, +then `picoclaw agent` (MCP `search` → `get` → `audit`). Gateway-only Compose: + ```bash docker compose --profile picoclaw up -d # already serving :8630 / :11435: diff --git a/docs/roadmap.md b/docs/roadmap.md index deff1e1..7759201 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -41,10 +41,12 @@ Epic [#16](https://git.produktor.io/eSlider/2dph/issues/16) closed. [#29](https://git.produktor.io/eSlider/2dph/issues/29) OQ1 contradiction resolution — **in** (`temporal_freshness`, `authority_pairing`). [#34](https://git.produktor.io/eSlider/2dph/issues/34) D23 flaggy CLI — **in**. +[#36](https://git.produktor.io/eSlider/2dph/issues/36) OQ5/D24 fact intervals / +as-of — **in** (not D16 `temporal_freshness`). ## Blockers -None for epic #16 (closed). Remaining v2: OQ4. +None for epic #16 (closed). Remaining v2: OQ4 (deferred). ``` question @@ -60,6 +62,8 @@ question ## Not v1 OQ4 YAML-first leafs. +OQ5/D24 fact intervals + as-of — **in** +([#36](https://git.produktor.io/eSlider/2dph/issues/36)). OCR (OQ2), duckdb-go (OQ3/D22), and D16 adjudication (OQ1) are in. ## Close epic #16 when diff --git a/docs/runbook.md b/docs/runbook.md index 4515400..8bf1d11 100644 --- a/docs/runbook.md +++ b/docs/runbook.md @@ -53,12 +53,15 @@ bin/brain/add.go --text "arc-1 runs Matrix" --root facts --source "compose.yml x bin/brain/index.go --rebuild --with-facts --with-chats bin/brain/search.go "LadybugDB vector index" # facts → info → web (D17) bin/brain/search.go "upstream flag" --no-web +bin/brain/search.go "who works where" --as-of 2025-01-01 # D24 intervals source <(./bin/cli/complete.go bash) # D23 flaggy complete bin/brain/get.go --body bin/brain/stats.go ``` -`--hop N` walks File → Commit → Person from each hit. Empty web results are `throttled`, not absence. +`--hop N` walks File → Commit → Person from each hit. `--as-of YYYY-MM-DD` +keeps leafs whose `valid_from`/`valid_to` cover that day (empty interval = +legacy always-on). Empty web results are `throttled`, not absence. Gap to v1: [roadmap](roadmap.md) / [epic #16](https://git.produktor.io/eSlider/2dph/issues/16). Ladybug 0.19: never `DROP INDEX` FTS/VECTOR (ghost catalog). Fresh indexes = @@ -66,6 +69,16 @@ delete `var/kb.lbug` then `--rebuild`. ## HTTP / MCP +```bash +bin/stack/start # brain :8630, wait until MCP search/get/audit +bin/stack/status # YAML: brain / reasoner / picoclaw +bin/stack/start-assistant # + qwen3.5:9b + PicoClaw agent (ask the brain) +bin/stack/start-assistant --no-attach +bin/stack/stop # compose stop; volumes kept +``` + +Same Compose services by hand: + ```bash docker compose up -d brain # :8630 Zig CGO serve docker compose --profile index run --rm index # rebuild @@ -73,6 +86,7 @@ docker compose --profile picoclaw up brain-mcp # MCP 127.0.0.1:8630 ``` `GET /openapi.json`, `POST /mcp`. Agent tool order: `search` → `get` → `audit`. +See [picoclaw.md](picoclaw.md). ## Reasoner (optional, D18) diff --git a/internal/brain/db.go b/internal/brain/db.go index cce5e9b..0284b1e 100644 --- a/internal/brain/db.go +++ b/internal/brain/db.go @@ -85,9 +85,18 @@ func openWithSandbox(epsv string) error { closeBrain() return fmt.Errorf("LOAD EXTENSION VECTOR: %w", err) } + migrateIntervalColumns() return nil } +// migrateIntervalColumns adds D24 valid_from/valid_to on existing Leaf tables. +// Fresh CREATE already has them; ALTER is a no-op when the column exists. +func migrateIntervalColumns() { + for _, col := range []string{"valid_from", "valid_to"} { + _, _ = conn.Query("ALTER TABLE Leaf ADD " + col + " STRING") + } +} + func closeBrain() { if conn != nil { conn.Close() diff --git a/internal/brain/http.go b/internal/brain/http.go index 1bd5311..6df1edc 100644 --- a/internal/brain/http.go +++ b/internal/brain/http.go @@ -21,8 +21,8 @@ func Ready() error { // HTTP is the in-process API used by bin/brain/serve.go. type HTTP struct{} -func (HTTP) Search(ctx context.Context, query string, limit int) ([]byte, error) { - hits, err := searchHits(query, "", "", limit) +func (HTTP) Search(ctx context.Context, query string, limit int, asOf string) ([]byte, error) { + hits, err := searchHits(query, "", "", limit, asOf) if err != nil { return nil, err } @@ -41,7 +41,7 @@ func (HTTP) Search(ctx context.Context, query string, limit int) ([]byte, error) var buf bytes.Buffer enc := json.NewEncoder(&buf) enc.SetEscapeHTML(false) - if err := enc.Encode(toJSONOut(hits, query, "", webOut)); err != nil { + if err := enc.Encode(toJSONOut(hits, query, "", asOf, webOut)); err != nil { return nil, err } return buf.Bytes(), nil diff --git a/internal/brain/rank/args.go b/internal/brain/rank/args.go index fdfab94..cfd0cae 100644 --- a/internal/brain/rank/args.go +++ b/internal/brain/rank/args.go @@ -5,10 +5,11 @@ import ( "strconv" "github.com/eSlider/2dph/internal/cli" + "github.com/eSlider/2dph/internal/facts" "github.com/integrii/flaggy" ) -const Usage = `usage: bin/brain/search.go "query" [--root facts|info] [--repo REPO] [-n N] [--hop N] [--json] [--no-web] +const Usage = `usage: bin/brain/search.go "query" [--root facts|info] [--repo REPO] [-n N] [--hop N] [--as-of YYYY-MM-DD] [--json] [--no-web] bin/brain/search.go serve [port] bin/brain/search.go --list-model source <(./bin/cli/complete.go bash)` @@ -19,6 +20,7 @@ type Options struct { Repo string Limit int Hop int + AsOf string JSONOut bool ListModel bool NoWeb bool @@ -35,6 +37,7 @@ func NewParser(opt *Options) *flaggy.Parser { p.String(&opt.Repo, "", "repo", "filter by repo") p.Int(&opt.Limit, "n", "n", "max hits") p.Int(&opt.Hop, "", "hop", "walk FROM_FILE depth 1-3") + p.String(&opt.AsOf, "", "as-of", "keep facts active on YYYY-MM-DD (D24)") p.Bool(&opt.JSONOut, "", "json", "JSON output") p.Bool(&opt.NoWeb, "", "no-web", "stay local") p.Bool(&opt.ListModel, "", "list-model", "print embedding model") @@ -64,6 +67,13 @@ func ParseArgs(args []string) (Options, error) { if opt.Hop > 3 { return opt, fmt.Errorf("--hop max is 3 (File → Commit → Person)") } + if opt.AsOf != "" { + day := facts.NormalizeDay(opt.AsOf) + if len(day) != 10 || day[4] != '-' || day[7] != '-' { + return opt, fmt.Errorf("--as-of must be YYYY-MM-DD, got %q", opt.AsOf) + } + opt.AsOf = day + } if opt.Query == "" && !opt.ListModel { return opt, fmt.Errorf("no query given") } diff --git a/internal/brain/rank/asof_test.go b/internal/brain/rank/asof_test.go new file mode 100644 index 0000000..df3718c --- /dev/null +++ b/internal/brain/rank/asof_test.go @@ -0,0 +1,34 @@ +package rank + +import "testing" + +func TestFilterAsOfKeepsXDropsY(t *testing.T) { + hits := []Hit{ + {ID: "x", Text: "Andrey works at X", ValidFrom: "2024-03-01", ValidTo: "2025-07-15"}, + {ID: "y", Text: "Andrey works at Y", ValidFrom: "2025-07-16", ValidTo: ""}, + {ID: "legacy", Text: "always true claim", ValidFrom: "", ValidTo: ""}, + } + out := FilterAsOf(hits, "2025-01-01") + if len(out) != 2 { + t.Fatalf("len=%d want 2: %+v", len(out), out) + } + if out[0].ID != "x" || out[1].ID != "legacy" { + t.Fatalf("got %+v", out) + } + if FilterAsOf(hits, "") == nil || len(FilterAsOf(hits, "")) != 3 { + t.Fatal("empty as-of must keep all") + } +} + +func TestParseArgsAsOf(t *testing.T) { + opt, err := ParseArgs([]string{"who works where", "--as-of", "2025-01-01", "--json"}) + if err != nil { + t.Fatal(err) + } + if opt.AsOf != "2025-01-01" { + t.Fatalf("AsOf=%q", opt.AsOf) + } + if _, err := ParseArgs([]string{"q", "--as-of", "not-a-date"}); err == nil { + t.Fatal("expected bad as-of error") + } +} diff --git a/internal/brain/rank/query.go b/internal/brain/rank/query.go index 26f30a4..a52cade 100644 --- a/internal/brain/rank/query.go +++ b/internal/brain/rank/query.go @@ -3,10 +3,12 @@ package rank // BM25 ranks best-first, so the top hits are the *highest* scores; cosine // distance ranks best-first ascending. Both mirror kblib.py. const FTSStmt = "CALL QUERY_FTS_INDEX('Leaf', 'id', $q) " + - "RETURN node.id, node.text, node.root, node.source, score, node.confidence ORDER BY score DESC LIMIT $n" + "RETURN node.id, node.text, node.root, node.source, score, node.confidence, " + + "node.valid_from, node.valid_to ORDER BY score DESC LIMIT $n" const VecStmt = "CALL QUERY_VECTOR_INDEX('Leaf', 'Leaf_vec', $q, $n) " + - "RETURN node.id, node.text, node.root, node.source, distance, node.confidence ORDER BY distance LIMIT $n" + "RETURN node.id, node.text, node.root, node.source, distance, node.confidence, " + + "node.valid_from, node.valid_to ORDER BY distance LIMIT $n" // HopStmt is the Cypher walk from a search hit. Depth 1 = File, 2 = Commit, 3 = Person. func HopStmt(depth int) string { diff --git a/internal/brain/rank/rank.go b/internal/brain/rank/rank.go index 6aed929..a90cfa6 100644 --- a/internal/brain/rank/rank.go +++ b/internal/brain/rank/rank.go @@ -5,6 +5,8 @@ package rank import ( "sort" "strings" + + "github.com/eSlider/2dph/internal/facts" ) type HopNode struct { @@ -23,17 +25,24 @@ type Hit struct { Source string `json:"-"` Score float64 `json:"score"` Snippet string `json:"snippet,omitempty"` + ValidFrom string `json:"valid_from,omitempty"` + ValidTo string `json:"valid_to,omitempty"` Hops []HopNode `json:"hops,omitempty"` } // rrfK dampens the contribution of low ranks; same constant as kblib.py. const rrfK = 60 -// RankAndFilter fuses the two hit lists, applies --root/--repo, then cuts to -// limit. Cutting first dropped every matching leaf ranked below the cut, so -// `--root facts` came back empty whenever info leafs filled the top N. -// limit <= 0 keeps everything. +// RankAndFilter fuses the two hit lists, applies --root/--repo/--as-of, then +// cuts to limit. Cutting first dropped every matching leaf ranked below the +// cut, so `--root facts` came back empty whenever info leafs filled the top N. +// limit <= 0 keeps everything. asOf empty skips interval filter (D24). func RankAndFilter(fts, vec []Hit, root, repo string, limit int) []Hit { + return RankAndFilterAsOf(fts, vec, root, repo, "", limit) +} + +// RankAndFilterAsOf is RankAndFilter with D24 fact-interval filter. +func RankAndFilterAsOf(fts, vec []Hit, root, repo, asOf string, limit int) []Hit { out := Hybrid(fts, vec, 0) if root != "" { out = FilterRoot(out, root) @@ -41,12 +50,30 @@ func RankAndFilter(fts, vec []Hit, root, repo string, limit int) []Hit { if repo != "" { out = FilterRepo(out, repo) } + if asOf != "" { + out = FilterAsOf(out, asOf) + } if limit > 0 && len(out) > limit { out = out[:limit] } return out } +// FilterAsOf keeps hits whose [valid_from, valid_to] covers asOf (D24). +// Empty intervals stay (legacy leafs). Empty asOf keeps all. +func FilterAsOf(hits []Hit, asOf string) []Hit { + if asOf == "" { + return hits + } + var out []Hit + for _, h := range hits { + if facts.ActiveAt(h.ValidFrom, h.ValidTo, asOf) { + out = append(out, h) + } + } + return out +} + // Hybrid merges FTS and vector hits by reciprocal rank fusion. // limit <= 0 returns the full fused list. func Hybrid(fts, vec []Hit, limit int) []Hit { diff --git a/internal/brain/search.go b/internal/brain/search.go index 12dff26..502d1f3 100644 --- a/internal/brain/search.go +++ b/internal/brain/search.go @@ -55,7 +55,7 @@ func runSearch(args []string) int { } defer closeBrain() - hits, err := searchHits(query, root, repo, limit) + hits, err := searchHits(query, root, repo, limit, opt.AsOf) if err != nil { fmt.Fprintf(os.Stderr, "search: %v\n", err) return 1 @@ -85,6 +85,7 @@ func runSearch(args []string) int { out := Dict{ {"query", query}, {"root_filter", root}, + {"as_of", opt.AsOf}, {"count", len(results)}, {"results", resultsToDicts(results)}, } @@ -96,13 +97,13 @@ func runSearch(args []string) int { enc := json.NewEncoder(os.Stdout) enc.SetIndent("", " ") enc.SetEscapeHTML(false) - return b2i(enc.Encode(toJSONOut(results, query, root, webOut))) + return b2i(enc.Encode(toJSONOut(results, query, root, opt.AsOf, webOut))) } fmt.Print(toYAML(out, 0)) return 0 } -func searchHits(query, root, repo string, limit int) ([]Hit, error) { +func searchHits(query, root, repo string, limit int, asOf string) ([]Hit, error) { emb, err := embedQuery(query) if err != nil { return nil, fmt.Errorf("embed: %w", err) @@ -115,7 +116,7 @@ func searchHits(query, root, repo string, limit int) ([]Hit, error) { if vec, err = queryVector(emb, limit*3); err != nil { fmt.Fprintf(os.Stderr, "vec: %v\n", err) } - return rank.RankAndFilter(fts, vec, root, repo, limit), nil + return rank.RankAndFilterAsOf(fts, vec, root, repo, asOf, limit), nil } func attachHops(hits []Hit, n int) error { @@ -220,15 +221,35 @@ func rowsToHits(res *lbug.QueryResult) ([]Hit, error) { if len(vals) >= 6 { conf = fmt.Sprint(vals[5]) } - hits = append(hits, Hit{ID: id, Text: text, Root: root, Source: source, Score: score, Confidence: conf}) + vf, vt := "", "" + if len(vals) >= 8 { + vf = nullStr(vals[6]) + vt = nullStr(vals[7]) + } + hits = append(hits, Hit{ + ID: id, Text: text, Root: root, Source: source, Score: score, + Confidence: conf, ValidFrom: vf, ValidTo: vt, + }) } return hits, nil } +func nullStr(v any) string { + if v == nil { + return "" + } + s := fmt.Sprint(v) + if s == "" { + return "" + } + return s +} + // JSON output types type jsonOut struct { Query string `json:"query"` RootFilter string `json:"root_filter"` + AsOf string `json:"as_of,omitempty"` Count int `json:"count"` Results []jsonHit `json:"results"` Web *rank.SecondSource `json:"web,omitempty"` @@ -241,10 +262,12 @@ type jsonHit struct { Confidence string `json:"confidence,omitempty"` Score float64 `json:"score"` Snippet string `json:"snippet,omitempty"` + ValidFrom string `json:"valid_from,omitempty"` + ValidTo string `json:"valid_to,omitempty"` Hops []rank.HopNode `json:"hops,omitempty"` } -func toJSONOut(hits []Hit, query, rootFilter string, web *rank.SecondSource) *jsonOut { +func toJSONOut(hits []Hit, query, rootFilter, asOf string, web *rank.SecondSource) *jsonOut { out := make([]jsonHit, len(hits)) for i, h := range hits { out[i] = jsonHit{ @@ -254,12 +277,15 @@ func toJSONOut(hits []Hit, query, rootFilter string, web *rank.SecondSource) *js Confidence: h.Confidence, Score: h.Score, Snippet: h.Snippet, + ValidFrom: h.ValidFrom, + ValidTo: h.ValidTo, Hops: h.Hops, } } return &jsonOut{ Query: query, RootFilter: rootFilter, + AsOf: asOf, Count: len(hits), Results: out, Web: web, @@ -278,6 +304,12 @@ func resultsToDicts(hits []Hit) []any { if h.Confidence != "" { d = append(d, KV{"confidence", h.Confidence}) } + if h.ValidFrom != "" { + d = append(d, KV{"valid_from", h.ValidFrom}) + } + if h.ValidTo != "" { + d = append(d, KV{"valid_to", h.ValidTo}) + } if h.Snippet != "" { d = append(d, KV{"snippet", h.Snippet}) } diff --git a/internal/facts/interval.go b/internal/facts/interval.go new file mode 100644 index 0000000..a923544 --- /dev/null +++ b/internal/facts/interval.go @@ -0,0 +1,44 @@ +package facts + +// Interval of truth for a fact leaf (D24 / OQ5). Not D16 source staleness. +// +// Empty valid_from and valid_to means "always" (legacy leafs). Empty asOf +// means "do not filter". Dates compare as YYYY-MM-DD (lexicographic). + +// NormalizeDay keeps the calendar day from ISO-8601 or bare dates. +func NormalizeDay(s string) string { + s = trimSpace(s) + if len(s) >= 10 && s[4] == '-' && s[7] == '-' { + return s[:10] + } + return s +} + +func trimSpace(s string) string { + i, j := 0, len(s) + for i < j && (s[i] == ' ' || s[i] == '\t' || s[i] == '\n' || s[i] == '\r') { + i++ + } + for j > i && (s[j-1] == ' ' || s[j-1] == '\t' || s[j-1] == '\n' || s[j-1] == '\r') { + j-- + } + return s[i:j] +} + +// ActiveAt reports whether a fact with [validFrom, validTo] holds at asOf. +// validTo empty = open-ended. Both ends inclusive. +func ActiveAt(validFrom, validTo, asOf string) bool { + asOf = NormalizeDay(asOf) + if asOf == "" { + return true + } + from := NormalizeDay(validFrom) + to := NormalizeDay(validTo) + if from != "" && asOf < from { + return false + } + if to != "" && asOf > to { + return false + } + return true +} diff --git a/internal/facts/interval_test.go b/internal/facts/interval_test.go new file mode 100644 index 0000000..d9dadd6 --- /dev/null +++ b/internal/facts/interval_test.go @@ -0,0 +1,73 @@ +package facts + +import "testing" + +func TestActiveAtOpenEnded(t *testing.T) { + // works at Y from 2025-07-16, no end + if !ActiveAt("2025-07-16", "", "2025-07-16") { + t.Fatal("inclusive valid_from") + } + if !ActiveAt("2025-07-16", "", "2026-01-01") { + t.Fatal("open-ended valid_to") + } + if ActiveAt("2025-07-16", "", "2025-07-15") { + t.Fatal("before valid_from must be inactive") + } +} + +func TestActiveAtClosedInterval(t *testing.T) { + // works at X 2024-03-01 .. 2025-07-15 + if !ActiveAt("2024-03-01", "2025-07-15", "2025-01-01") { + t.Fatal("mid interval") + } + if !ActiveAt("2024-03-01", "2025-07-15", "2024-03-01") { + t.Fatal("inclusive start") + } + if !ActiveAt("2024-03-01", "2025-07-15", "2025-07-15") { + t.Fatal("inclusive end") + } + if ActiveAt("2024-03-01", "2025-07-15", "2025-07-16") { + t.Fatal("day after end") + } + if ActiveAt("2024-03-01", "2025-07-15", "2024-02-28") { + t.Fatal("day before start") + } +} + +func TestActiveAtEmptyIntervalAlwaysTrue(t *testing.T) { + // legacy leafs without intervals stay visible for any as-of + if !ActiveAt("", "", "2025-01-01") { + t.Fatal("empty interval must remain active") + } + if !ActiveAt("", "", "") { + t.Fatal("no as-of means all active") + } +} + +func TestActiveAtEmptyAsOfKeepsAll(t *testing.T) { + if !ActiveAt("2099-01-01", "2099-12-31", "") { + t.Fatal("empty as-of must not filter") + } +} + +func TestAsOfPickXNotY(t *testing.T) { + // Acceptance from #36: as of 2025-01-01 → X, not Y + xFrom, xTo := "2024-03-01", "2025-07-15" + yFrom, yTo := "2025-07-16", "" + asOf := "2025-01-01" + if !ActiveAt(xFrom, xTo, asOf) { + t.Fatal("X must be active as of 2025-01-01") + } + if ActiveAt(yFrom, yTo, asOf) { + t.Fatal("Y must be inactive as of 2025-01-01") + } +} + +func TestNormalizeDayTrimsTime(t *testing.T) { + if NormalizeDay("2025-01-01T12:00:00Z") != "2025-01-01" { + t.Fatalf("got %q", NormalizeDay("2025-01-01T12:00:00Z")) + } + if NormalizeDay("2025-01-01") != "2025-01-01" { + t.Fatalf("got %q", NormalizeDay("2025-01-01")) + } +} diff --git a/internal/httpapi/mcp.go b/internal/httpapi/mcp.go index 3f39668..b67c5c5 100644 --- a/internal/httpapi/mcp.go +++ b/internal/httpapi/mcp.go @@ -105,11 +105,18 @@ func (s *Server) mcpCall(r *http.Request, params json.RawMessage) (any, error) { if limit < 1 || limit > 100 { return mcpText(`{"error":"n must be int 1..100"}`, true), nil } + asOf := "" + if raw, ok := p.Arguments["as_of"]; ok { + asOf = strings.TrimSpace(fmt.Sprint(raw)) + if asOf == "" { + asOf = "" + } + } if !s.tryAcquire(r) { return nil, fmt.Errorf("cancelled") } defer s.release() - body, err = s.api.Search(r.Context(), q, limit) + body, err = s.api.Search(r.Context(), q, limit, asOf) case "get": id := strings.TrimSpace(fmt.Sprint(p.Arguments["id"])) if id == "" || id == "" { diff --git a/internal/httpapi/server.go b/internal/httpapi/server.go index 8dea1c3..2c52e7c 100644 --- a/internal/httpapi/server.go +++ b/internal/httpapi/server.go @@ -24,7 +24,7 @@ import ( // API is the in-process brain surface. Production serve.go wires internal/brain. type API interface { - Search(ctx context.Context, query string, limit int) ([]byte, error) + Search(ctx context.Context, query string, limit int, asOf string) ([]byte, error) Get(ctx context.Context, id string, body bool) ([]byte, error) Stats(ctx context.Context) ([]byte, error) Audit(ctx context.Context) ([]byte, error) @@ -85,11 +85,12 @@ func (s *Server) handleSearch(w http.ResponseWriter, r *http.Request) { } limit = n } + asOf := strings.TrimSpace(r.URL.Query().Get("as_of")) if !s.acquire(w, r) { return } defer s.release() - body, err := s.api.Search(r.Context(), q, limit) + body, err := s.api.Search(r.Context(), q, limit, asOf) writeAPI(w, body, err) } @@ -187,13 +188,18 @@ type ExecSearcher struct { Timeout time.Duration } -func (b ExecSearcher) Search(ctx context.Context, query string, limit int) ([]byte, error) { +func (b ExecSearcher) Search(ctx context.Context, query string, limit int, asOf string) ([]byte, error) { if b.Timeout == 0 { b.Timeout = 60 * time.Second } ctx, cancel := context.WithTimeout(ctx, b.Timeout) defer cancel() - cmd := exec.CommandContext(ctx, b.CmdPath, "--json", "-n", strconv.Itoa(limit), query) + args := []string{"--json", "-n", strconv.Itoa(limit)} + if asOf != "" { + args = append(args, "--as-of", asOf) + } + args = append(args, query) + cmd := exec.CommandContext(ctx, b.CmdPath, args...) out, err := cmd.Output() if err != nil { var exitErr *exec.ExitError diff --git a/internal/httpapi/server_test.go b/internal/httpapi/server_test.go index 01d8482..f34fe55 100644 --- a/internal/httpapi/server_test.go +++ b/internal/httpapi/server_test.go @@ -21,10 +21,10 @@ type fakeSearcher struct { calls int active atomic.Int32 maxSeen atomic.Int32 - callback func(q string, limit int) ([]byte, error) + callback func(q string, limit int, asOf string) ([]byte, error) } -func (f *fakeSearcher) Search(ctx context.Context, query string, limit int) ([]byte, error) { +func (f *fakeSearcher) Search(ctx context.Context, query string, limit int, asOf string) ([]byte, error) { f.mu.Lock() f.calls++ f.mu.Unlock() @@ -44,7 +44,7 @@ func (f *fakeSearcher) Search(ctx context.Context, query string, limit int) ([]b } } if f.callback != nil { - return f.callback(query, limit) + return f.callback(query, limit, asOf) } return []byte(`{"query":"` + query + `","count":0,"results":[]}`), nil } @@ -109,7 +109,7 @@ func TestSearchMissingQuery(t *testing.T) { } func TestSearchReturnsSearcherResult(t *testing.T) { - fs := &fakeSearcher{callback: func(q string, limit int) ([]byte, error) { + fs := &fakeSearcher{callback: func(q string, limit int, asOf string) ([]byte, error) { return []byte(`{"query":"` + q + `","count":1,"results":[{"id":"x"}]}`), nil }} h := NewServer(fs, 1) @@ -168,7 +168,7 @@ func TestSearchRejectsBadLimit(t *testing.T) { } func TestGetLeaf(t *testing.T) { - fs := &fakeSearcher{callback: func(q string, limit int) ([]byte, error) { + fs := &fakeSearcher{callback: func(q string, limit int, asOf string) ([]byte, error) { return []byte(`{}`), nil }} h := NewServer(fs, 1) diff --git a/internal/httpapi/spec.go b/internal/httpapi/spec.go index f20bdff..8066438 100644 --- a/internal/httpapi/spec.go +++ b/internal/httpapi/spec.go @@ -35,6 +35,7 @@ var Ops = []Op{ Params: []Param{ {Name: "q", In: "query", Type: "string", Description: "search query", Required: true}, {Name: "n", In: "query", Type: "integer", Description: "hit limit 1..100 (default 10)"}, + {Name: "as_of", In: "query", Type: "string", Description: "YYYY-MM-DD; keep facts active on that day (D24)"}, }, }, { @@ -54,6 +55,8 @@ var Ops = []Op{ {Name: "text", In: "query", Type: "string", Description: "leaf text (omit for CLI hint)"}, {Name: "root", In: "query", Type: "string", Description: "facts or info (default info)"}, {Name: "source", In: "query", Type: "string", Description: "evidence pointer; facts need two sources"}, + {Name: "valid_from", In: "query", Type: "string", Description: "fact interval start YYYY-MM-DD (D24)"}, + {Name: "valid_to", In: "query", Type: "string", Description: "fact interval end YYYY-MM-DD inclusive (D24)"}, }, }, {Path: PathOpenAPI, Method: "get", ID: "openapi", Summary: "OpenAPI 3 document for this server"}, diff --git a/skills/brain/SKILL.md b/skills/brain/SKILL.md index d6c2eb6..f377f51 100644 --- a/skills/brain/SKILL.md +++ b/skills/brain/SKILL.md @@ -26,6 +26,7 @@ second independent source when local roots cannot confirm. An answer is bin/brain/search.go "Matrix federation" # pointers + snippets, YAML bin/brain/search.go "onlyoffice postgres" --root facts # restrict to confirmed bin/brain/search.go "where is cs-lexicon" --json | yq '.[].ref' +bin/brain/search.go "who works where" --as-of 2025-01-01 # D24 intervals bin/brain/add.go --text T --root facts --source "a.md x b.md" bin/brain/get.go --body # full chunk only when needed bin/brain/stats.go # index health @@ -34,6 +35,8 @@ bin/brain/eval.go # recall@5 >= 0.95 gate ( `bin/kb/search` is a deprecated wrapper. `--hop N` walks `FROM_FILE` / `HAS_VERSION` / `AUTHORED` from each hit (1=File, 3=Person). +`--as-of YYYY-MM-DD` keeps leafs whose `valid_from`/`valid_to` cover that day +(empty interval = always; not D16 source staleness). ## Rules diff --git a/skills/picoclaw/SKILL.md b/skills/picoclaw/SKILL.md index d51c4f4..e319396 100644 --- a/skills/picoclaw/SKILL.md +++ b/skills/picoclaw/SKILL.md @@ -12,6 +12,12 @@ PicoClaw speaks MCP at `POST /mcp` on `bin/brain/serve.go`. Compose profile `picoclaw` runs the official `sipeed/picoclaw` gateway plus `brain-mcp` (see [docs/picoclaw.md](../../docs/picoclaw.md)). +```bash +bin/stack/start-assistant # brain + qwen3.5:9b + gateway + picoclaw agent +bin/stack/status +bin/stack/stop +``` + ## Tool order (before a factual reply) 1. **`search`** — facts root first, then info. The `web` block is a second