~/scire/session/0001 -- zsh 120x40 :: utf-8 :: dark
scire@dev:~$  
scire 0.4.2-dev :: a knowledge runtime for the command line
build "hex-326f515a" compiled // 2026-03-19
platform aarch64-apple-darwin :: tty 120x40
 
scirelatin v. "to know, to understand by direct evidence"
a workspace where reading the system is using the system.
 
> type help to list available channels
> press [tab] to navigate the session buffer
> press [/] to focus the prompt
   ░██████╗░█████╗░██╗██████╗░███████╗  ██████╗░███████╗██╗░░░██╗
   ██╔════╝██╔══██╗██║██╔══██╗██╔════╝  ██╔══██╗██╔════╝██║░░░██║
   ╚█████╗░██║░░╚═╝██║██████╔╝█████╗░░  ██║░░██║█████╗░░╚██╗░██╔╝
   ░╚═══██╗██║░░██╗██║██╔══██╗██╔══╝░░  ██║░░██║██╔══╝░░░╚████╔╝░
   ██████╔╝╚█████╔╝██║██║░░██║███████╗  ██████╔╝███████╗░░╚██╔╝░░
   ╚═════╝░░╚════╝░╚═╝╚═╝░░╚═╝╚══════╝  ╚═════╝░╚══════╝░░░╚═╝░░░

   > quiet mastery of text-based tools
                    
$ scire status --short
runtime ready  // 9 panes loaded
grid aligned  // 120 cols × 40 rows
palette: github-dark-syntax
 
scroll ↓ or click a tab to begin reading
~/scire/knowledge/overview.md read-only :: 184 lines

## KNOWLEDGE SYSTEMS

$ scire read "./knowledge"

Scire treats knowledge as a stream of structured text: each note is a file, each connection a path, each idea a command you can re-run later. There are no apps to open, no canvases to navigate, no inboxes to clear — only a session, a prompt, and the long memory of every line you have written.

   ┌─────────────┐    ┌─────────────┐    ┌─────────────┐
   │  capture    │──▶│   refine    │──▶│   recall    │
   │  raw text   │    │  & link    │    │   on demand │
   └─────────────┘    └─────────────┘    └─────────────┘
          │                  │                  │
          └─── append-only ──┴──── content-addressable ────┘
                    
  • + append-only journals, never silently rewritten
  • + content-addressable links between every note
  • + every command leaves a trace you can grep later
  • - opaque sync layers and proprietary blobs
  • - "AI summaries" that hide the original sentence

## A SESSION TRANSCRIPT

$ scire capture
// pasted from clipboard, 412 chars
 stored as ~/scire/n/2026-03-19T0641.md
 indexed (12 tokens, 4 backlinks)

$ scire link --from 2026-03-19T0641 --to "terminal-aesthetic"
 link added  // graph edges: 1842

$ scire recall "why mono?"
3 matches in 12ms
  1. ~/scire/n/2026-02-04T2203.md   // "the grid is the page"
  2. ~/scire/n/2026-02-19T0911.md   // "ligatures earn their keep"
  3. ~/scire/n/2026-03-09T1648.md   // "monospace as restraint"

$ scire diff --since "yesterday"
+ added     14 notes
+ added     37 links
- removed   2  drafts
// net entropy: -0.018
                    
~/scire/architecture.tree tree :: depth=4

## ARCHITECTURE

   scire/
   ├── runtime/
   │   ├── parser.rs            // every line is a token
   │   ├── grid.rs              // 9.6 × 20 cell math
   │   └── prompt.rs            // $ and > primitives
   ├── store/
   │   ├── append.rs            // no in-place edits
   │   ├── cas.rs               // content addresses
   │   └── index.rs             // inverted, on-disk
   ├── interface/
   │   ├── tty.rs               // the real one
   │   ├── web.rs               // the page you read
   │   └── tabs.rs              // tmux-style panes
   └── scripts/
       ├── capture.sh           // stdin → store
       ├── recall.sh            // query → ranked
       └── diff.sh              // two states → text
                    
PROCESSES·····················07
PIPES··························12
PERSISTED STREAMS···········04
EPHEMERAL CACHES············02
RPC SURFACES·················00
parse 88%
store 71%
index 54%
render 97%

Each subsystem is a small program, plain enough to be re-read on a tired Tuesday. The whole system should fit in a single mental working set — no hidden states, no gods, no daemons.

~/scire/process.log tail -f :: streaming

## PROCESS

The work is a recursion of four verbs: capture, refine, link, recall. Each verb is a subcommand. Each subcommand is a small program. Each program writes to stdout, so a session is auditable, replayable, diffable.

  1. [01] capture — raw input lands in an append-only journal, timestamped to the millisecond.
  2. [02] refine — you re-read what you wrote and re-write it tighter, line by line.
  3. [03] link — explicit references between notes form a content-addressed graph.
  4. [04] recall — future-you queries the graph from the prompt and reads the result.

## LIVE LOG

06:31:28 INFO  daemon started, pid 38114
06:31:28 INFO  mounted ~/scire at /store/01
06:31:29 INFO  indexed 12482 notes in 312ms
06:32:04 WARN  link cycle detected: "tmux""panes"
06:32:04 INFO  resolved by mtime, kept newer
06:33:11 INFO  capture 412 chars from stdin
06:33:11 INFO  wrote ~/scire/n/2026-03-19T0641.md
06:34:02 INFO  recall "why mono?"3 hits, 12ms
06:34:48 +     note created — "the grid is the page"
06:35:17 INFO  graph snapshot — nodes=1842 edges=5117
06:36:00 INFO  diff vs yesterday: +14/-2  // entropy -0.018
06:36:30 INFO  idle — awaiting prompt 
                    
~/scire/manifest.diff git diff :: HEAD~1..HEAD

## MANIFEST

diff --git a/MANIFEST.md b/MANIFEST.md
--- a/MANIFEST.md
+++ b/MANIFEST.md
@@ -1,18 +1,22 @@
- knowledge is a feed
+ knowledge is a session

- the page is a destination
+ the page is a transcript

- the cursor blinks for attention
+ the cursor blinks for the next move

- decoration through chrome
+ decoration through alignment

- the user is a customer
+ the user is a reader

- "experience" is the product
+ the prompt is the product
                
copied to clipboard