Kelvin Steiner steinerkelvin

My email setup: filters as code + local mirror + indexed search + TUI

Gmail with my data on disk and my filter rules in git. No vendor lock on the routing logic, full-text search that doesn't depend on an internet round-trip, and a TUI for triage. Built as five small CLI tools wired together with a justfile.

This is the shape of the system, not the secrets. The Nix module that installs it is reproduced inline below; my account configs and OAuth credentials live in private stores. Friends can lift the structure into their own dotfiles in an afternoon.

The stack

Five tools, each doing one thing:

description	Kaether direction brainstorm -- layered agent OS with ocap, shared skills, CRDT state, Agentica runtime, and the path from local coordination to Torus-scale swarms
project	kaether
type	brainstorm
created	2026-04-10
share	close

Kaether Ideas

User: Explain the relations between the Abilene Paradox, pluralistc ignorance and the spiral of silence.

Assistant: The Abilene Paradox, pluralistic ignorance, and the spiral of silence are related concepts in social psychology that deal with group dynamics, conformity, and decision-making processes. Here's how they are connected:

Abilene Paradox:

Occurs when a group collectively decides on a course of action that is contrary to the preferences of most of the individuals in the group.
People go along with the decision to avoid conflict or to not "rock the boat," even though it's not what they want.
Results in a decision that no one really wants, but everyone feels pressured to agree to.

Pluralistic Ignorance:

simple TLS/SSL termination with Traefik

This is a simple Docker setup of a Traefik container to do SSL/TSL terminantion (you delegate SSL/TLS to another service instead of doing it in the application itself).

It works with applications running on the host (instead of another container) if using the following on Docker Compose:

 extra_hosts:

Keybase proof

I hereby claim:

I am steinerkelvin on github.
I am kelvinsantos (https://keybase.io/kelvinsantos) on keybase.
I have a public key ASB-bPsqg4-5Ptnh7nKuug7MReFWk--Td-CyZ6DRttsEAAo

To claim this, I am signing this object:

	import { Enum, MatchDictFor, match } from "."

	export type Option<T> = T \| null

	export type Result<T, E> = Enum<{
	Ok: T,
	Err: E,
	}>

	interface ResultI<T, E> {

	from typing import Callable, TypeVar, Generic, Protocol

	T = TypeVar("T")

	class SetterGetterFn(Generic[T], Protocol):
	def __call__(self, x: T = ..., /) -> T:
	...

	def create_state_fn(default: Callable[..., T]) -> SetterGetterFn[T]:
	"""

	// Some magic from
	// https://stackoverflow.com/questions/65750673/collapsing-a-discriminated-union-derive-an-umbrella-type-with-all-possible-key

	// I replaced `undefined` usages with the placeholder below so we can exclude
	// it properly on the last definition.

	declare const PLACEHOLDER: unique symbol
	type Placeholder = typeof PLACEHOLDER

	// Magic as far as I'm concerned.

	[ids]
	04d9:a096

	[main]
	capslock = layer(custom_caps)

	[custom_caps:M]

	#define ASPTF_ARGS _BUFFER, _TAM

	/**
	* Aloca automaticamente o espaço necessário para uma string formatada
	* resultante de um "sprintf".
	*
	* @param dest Variável onde armazenar a string formatada resultante
	* @param sptf Expressão de snprintf que deve ser do formato:
	* `snprintf(ASPTF_ARGS, <formato>, ... )`, que é equivalente a:
	* `snprintf(_BUFFER, _TAM, <formato>, ... )`