Repository navigation
Releases
v0.1.3
This security release fixes file and command rules, record verification, and the handling of skipped kernel checks.
If you use Tego v0.1.0, v0.1.1 or v0.1.2, upgrade and restart your runs.
The v0.1.1-rc.1 prerelease is affected too.
Security
- Denied reads at tiers cgroup and bpflsm: a host could already show a denied folder, or part of it, at another
readable place on the same filesystem. A read through that place could miss the denial. This affects v0.1.0
through v0.1.2. The fixed build refuses to start where the selected mechanism cannot hold the denial through
those names. A decision plane still handles whole-folder names on the same filesystem where supported.
Different filesystem instances that show the same data remain a limit. So do later host mounts, ancestor
renames and rules that protect names rather than existing paths. Tier landlock keeps its stated alias limit.
Hosts that already show a home or project folder at a second place, such as Fedora Atomic, toolbox and
distrobox hosts, can meet this refusal where the selected mechanism cannot hold that second place;
tego doctornames the places it found. - Protected writes: in v0.1.0 through v0.1.2, a write or ask grant could reach kernel control files or Tego's own
files through another existing mount. A user-writable Tego binary with another hard link was also exposed.
An agent could change another run's controls or a binary used by a later run. Compile and run start now refuse
grants that reach these protected places within the mount analysis's stated limits. Mount changes after compilation, separate
filesystem instances and backing storage whose identity is not known remain limits. Keep that storage outside
every write and ask grant. Processes outside Tego still have their ordinary rights. - Command rules in v0.1.0 through v0.1.2 could miss some subcommand entries in
exec.denyandexec.askfor
systemctl, go, npm, pip and aws. It matters when the program may run and the contract relies on a subcommand
entry. These command forms now match; some other tools refuse more commands where their parsing is
uncertain. Whole-program refusals, file rules, network rules and ordinary OS privileges applied throughout.
exec.askis still reserved and refuses; it does not ask a person. - Option-specific npm refusals could be missed, and some npm argument combinations could be admitted under
an allow entry for another command. Command rules now check the command and options npm reads, including
value assignments, option spellings and shorthands. Existing conservative refusals remain in place. - AWS options written as assignments remain options when a preceding option needs a value. Missing values
refuse constrained command rules; uncertain spellings retain conservative readings. - Command entries containing an option terminator follow the tool's command, default command and argument
boundaries. Unknown tools keep literal argument regions. Unestablished allow meanings and unsupported
separator spellings fail to compile. Refusals of the compared inputs remain (the known limits below name
one exception), and allow entries retain their prior limits.
An allow entry does not admit its command when the command line puts--before the subcommand; write the command without it. - This release decides command rules with two readings of each entry and command line: the corrected reading
and a retained earlier reading kept as a floor. A deny or ask entry applies when either reading matches. An
allow entry for a constrained program admits a command only when both readings do, and an allow entry the
retained reading cannot interpret fails to compile, naming the entry. So some commands that an allow entry
would admit under the corrected reading alone stay refused in this release. - Known limits of command rules in this release. The reading that
tego compileprints for a command entry
is one of the two readings the decision uses; where they differ the decision is the stricter one, so
the printed reading can show more than is allowed or less than is refused. An entry whose option word
has an empty name is read as written; earlier versions could read it as a command's only long option, so a
deny or ask entry written that way no longer matches that option, and compile does not warn:
write the option's name. The comparison with the released matcher covers generated single-entry
contracts and pinned cases, not every contract (GAPS C72). - Since v0.1.0, some Git command entries could miss a built-in run under one of Git's alternative names.
Deny or ask entries namingadd,init,fsckorblamewere affected, as were entries for commands found in
Git's helper directory but absent from Tego's command table. The fixed build applies those entries to the
affected names in Tego's table and helper list. If you rely on these Git command rules, upgrade. - Ledger roots outside
~/.tego: versions v0.1.0 through v0.1.2 (including v0.1.1-rc.1) checked the ledger root's
parent when deciding whether a write grant was inside a run's folder. With such a configuredledger_root, a
grant inside an existing run's folder was not refused and could change that run's record and control files.
Compile now checks the ledger root itself and refuses these grants, including through another mount of the same
filesystem within the compile-time mount boundary.
This defect alone did not let the agent write its own newly created run folder: run start separately
refuses a direct grant covering that folder. Upgrade if you use a ledger root outside~/.tego, and review write
grants that reach existing run folders. - Record verification in v0.1.0 through v0.1.2 could accept a record only as far as the line before an altered
final line. This required write access to the record and no populated anchor entry for that run. Verification
now checks a closed final JSON value and rejects malformed trailing content. An intact populated anchor
remains necessary to detect a removed tail. An integrity check does not prove who made a record or that the
actions in it were allowed. - Kernel checks at root tiers: in v0.1.0 through v0.1.2, some preempting kernels could skip a program that should
decide an action, without recording that loss. LSM checks were exposed before Linux 6.2, or before 6.1.54 in
the 6.1 series, when kernel code could be preempted. The measured distribution defaults did not expose that
older case. Exec pins were exposed on measured Linux 7.0 configurations. Listener cleanup could skip on
preempting kernels. A run now reads the relevant skip counters. A detected
decision skip ends a governed run with reasonerrorand a gap saying its rules may not have held. An adoption
reports the gap without ending the agent. Doctor withholds unsafe LSM modes and kernel exec assurance on the
affected configurations. Exec pins and listener cleanup can still be skipped. Detection does not undo an
action. Shared counters can end an unrelated run, and unmeasured vendor kernels remain a limit.
Added
- In a terminal,
tego doctor,test,watch,learn,run,adoptandagentsend with anext:line on
stderr that names the one command to type next.TEGO_HINTS=offturns these lines off, andTEGO_HINTS=on
turns them on where stderr is not a terminal; they are never printed with--json. No stdout line changes:
tego doctor's Ready or Not ready line is on stderr, after its report. tego learn <run> --save <name>writes the proposed contract, compiled first, to the user registry, so
tego run <name>finds it. It refuses a name thattego runwould not find alone from the working directory
or from the run's folder, a name that starts with-, and running under sudo for another user. The contract
it saves hasreason: {reads: on}, so a read the contract refuses is recorded at tier landlock too and a
newcomer sees the refusal on every run; one line says what it costs (each read open about 17 µs slower), and
--reads offleaves it out. The printed proposal,--outand contracts already saved do not change.tego learn --allow-host <host>[:<port>](repeatable, at most 8) names the service a watched run reached at
some of its addresses. Tego looks the name up now and writestcp://<host>:<port>(udp://for UDP) in place
of each address the run reached that the name resolves to. A later run is then allowed the addresses Tego's own
lookups of the name return during that run, not only the one this run reached. An address no name may stand for
(loopback, link-local, cloud metadata, or a range in the machine config'sdenied_resolved_addresses) stays an
address. It writes nothing and exits 1 when the name does not resolve within 2 s, covers no address the run
reached, resolves to a private address the run did not reach, or resolves to an address learn withheld after a
secret read. It never chooses a name itself. When a proposal still allows addresses, stderr names them, and the
next:line aftertego watchandtego learnadds--allow-host <host>. The machine's resolver is never
counted as an address to name (see Changed).- After a run whose refused reads were not recorded, a
reads:line on stderr says so, and
tego receipt --jsoncarriesreads_notified. tego setupchecks the machine from your shell and lists the six steps from install to an agent held by its own
contract, each with the fact that decided it, then the one command to type next. It asks nothing, starts no
program and needs no root;--jsonprints one object (tego.setup/1) and-vsays where each fact was read. It
stores its check in~/.tego/state/check.json, used only on the same boot with the same tego build;tego doctor
still writes nothing. The installer ...
v0.1.2
This patch fixes one flaw in how command rules read long command lines. It changes no other code.
Security
-
Command rules (
exec.deny,exec.ask, andexec.allowentries with words after the program): Tego decides a long
command on its first part (32 arguments, or fewer when they pass 8 KiB) when the rest cannot change the answer. In
three forms the rest could still change it, and the command was decided on its first part anyway, so it ran though
its whole command line is refused:- python's
-mas the last argument of the first part, with the module after it: an entry on the module, such as
deny: [pip install]or a baredeny: [pip], was not applied; - cargo's
--configor gcloud's--flags-fileafter the subcommand:--configcan define an alias that runs
cargo publishunder another name, anddeny: [cargo publish]was not applied to it; underallow: [cargo build]
such acargo buildran, which Tego refuses because it cannot tell which subcommand runs; - options after the
-cof sh, bash, dash, zsh or ksh, or after the-eof perl or ruby, enough of them that the
whole command line cannot be resolved (more than 16 ways to read it), which Tego refuses.
Present since v0.1.0: the new tests fail on trees of v0.1.0 and v0.1.1 (unit tests, not run in a guest). The file
and network rules, and which programsexec.allowlets run at all, were not affected. If you rely on command
entries inexec.deny,exec.askorexec.allow, upgrade to v0.1.2. These commands are now read to their end,
or until no later argument can change the answer. A command that would have to be read past 8192 arguments or
128 KiB of argument text to be decided is refused (args-unreadable), where before it could be decided on its
first part. - python's
Record v
1 (spec/record/v1, record minor 29)
Contract schema
0 (spec/agent/v0; the field set may change without notice before v0.2.0, docs/VERSIONING.md section 3)
Kernel minimums
Linux 5.14 with Landlock ABI 2 or newer, which is Linux 5.19 or a backport such as RHEL 9's 5.14; tested from 6.1 and on
RHEL 9 and 10, as AlmaLinux 9.8 and 10.2, with what ran where in docs/TIERS.md (tier 1: ABI 1 is unsupported,
and features are gated per ABI, see spec/backend/CAPABILITIES.md;
tier 2 needs root and cgroup v2; tier 3 needs root and bpf in the LSM list). A unix socket under an fs.write path is
admitted without a unix: entry only with the kernel's socket diagnostics for AF_UNIX (CONFIG_UNIX_DIAG, built in
or the loadable unix_diag module); without them such a socket is refused unix-origin-unread, and tego doctor says so.
Syscall outcome hooks require readable tracefs event formats with an eight-byte ret at offset 16; unsupported
or unverified layouts withhold root tiers. The kernel version minimum is unchanged.
Container image
ghcr.io/attention-span-ai/tego@sha256:ca05e8f43f706d0f2263540dcd6d47a5ef611f350b148f8df25b1c4f9aeb5117 (linux/amd64, linux/arm64).
v0.1.1
This patch tightens the built-in refusals around an agent and checks the file identities and security labels
used for approvals. Receipts and the dashboard give more reliable results for long runs, tego rules brings the
rules view to the terminal, and release automation adds signed container images alongside the binaries. MCP tool
rules remain a preview, with the limits below.
Security
- Tiers cgroup and bpflsm, on overlayfs: on kernels that have
file_operations.fop_flagsbut keep FMODE_BACKING at
bit 25 (RHEL 9.8, RHEL 10.0 to 10.2, Linux 6.10 to 6.13, and 6.12 stable before 6.12.105), the decision plane did
not recognise an overlayfs backing file. An agent could map a file under a write entry readable andmprotectit
executable, which lets it run that file's machine code although noexec.allowcovers it. A direct executable
mmapwas still refused. Present since v0.1.0. The plane now recognises a backing file whether FMODE_BACKING is
bit 24 or bit 25, which covers every kernel checked from 5.14 to 7.1. Measured on AlmaLinux 9.8 and 10.2 for a
file already on the overlay mount: the old build allowed it and the new build refuses it. The other kernels in
the list are read from their headers. - Syscall outcome hooks refuse loading or adoption unless tracefs proves an eight-byte return at offset 16.
Doctor and run tier selection withhold root tiers on unverified layouts and retain the reason. - Enforcing runs refuse protected host IPC, Tego control surfaces and other terminals before grants. Own
runtime, fixed SSH-agent exceptions, inherited terminals and policy-checked own PTYs work; exact
container-daemon socket grants warn of escape authority. Root tiers add native Unix peer checks and reject
io_uring: true. Limits remain for inherited descriptors, new outside FIFOs, unlisted server paths and
datagram/copied-path cases without native checks. - Held opens require matching complete AppArmor labels with proven root namespace visibility, or matching
SELinux contexts andfscreatefor potential creation. Smack refuses: another task's rules cannot be queried.
Unknown facts refuse approvals and alternates. An unprivileged syscall discovers LSMs behind masked
securityfs. Containers need them; hidden AppArmor namespace depth givesEACCES/held-label-unavailableby
default. Administrators can waive only unreadable depth withfs.apparmor_assume_root_namespace: truein the
top-level contract, accepting hidden-ancestor risk; compile warns andrun_start.best_effortrecords it. - Held reads track protected identities through renames, hard links, replacements and moves, including
denied-directory descendants. Approvals (including write-only) and alternates recheck opened identities. Lost
mutation history or unsupported filesystems refuse held reads; new name matches outside the launch snapshot
and mount changes undone between reads remain limits. Held writes recheck live blocks. - Record, lock and anchor writers reject hard links for everyone. Owners can still alter records; historical
readers and garbage collection gain no link-count checks. - Stdio MCP starts pin the admitted shim's exact child before exec, refusing preexisting children; failed
registration refuses.mcp relay *grants use an authenticated private stage, honoring denies/asks without
permitting other children or subcommands. Protocols v1/v2 refuse: rebuild launcher and shims together. MCP
stays a preview (tego serve --previewexposes its dashboard link): ptrace/socket-copy authority can bypass
decisions and their record; alternate command spellings need separate exec rules (GAPS C50).
Hardening remains proposed in ADR
0126. - Boundary adoption arms its empty destination before moving processes. The agent cannot use
CAP_SYS_ADMINin
any user namespace, covering mount changes and mount-namespace installation; missing hook proof refuses
adoption. Record-only adoption stays unrestricted. Earlier changes, operations past capability checks, outside
processes, inherited descriptors/mappings and pre-attachment actions remain outside protection. Adoption
refuses network contracts (net:); it cannot enforce them. - Node rules scan config and dotenv options wherever Node scans them. Expanded parsing needs exact standalone
Linux x64 builds 20.19.4 or 22.21.1; others keep bounded parsing plus these scans. Unknown builds may miss
code-loading options; externalNODE_OPTIONSpreloads remain unread. - The release is built with Go 1.27.4, which fixes GO-2026-6859 in net/http: an HTTP/1 server could crash when a
handler reads a request body limited byMaxBytesReaderwhile response headers are written on another goroutine.
tego-control's dashboard is an HTTP/1 server on 127.0.0.1 and limits form posts withMaxBytesReader; it reads
each form in the handler's own goroutine, before writing a response.
Fixed
- On RHEL 9 (AlmaLinux 9.8 tested), systemd turns on the memory and pids controllers by default, but not cpu.
tego doctorfailed on that and found no tier, so every enforced run was refused, including runs with no
limits, for a user and for root. Now only a run that setslimits.cpuorlimits.cpu_weightis refused, at
start, and doctor and the refusal give the one-time setup that turns cpu on (docs/TIERS.md, GAPS B15). A
limits.cpuceiling in/etc/tego/config.yamlgives everytego runa CPU limit, so with one they are all
refused, althoughtego doctorstill reports tier landlock for a user. Memory and process limits apply. For
root, doctor's fix now names a CPU weight on system.slice instead of user@.service, because a hand-written
+cpuin the root cgroup does not last under systemd. - RHEL 9 root-tier runs with
net.listencan attach their required bind/listen outcome hooks. Bind, listen
and exec outcomes use the individual syscall event's BTF context; v0.1.0's listener preparation failed on
the tested RHEL 9 5.14 layout. No required hook or enforced property is dropped. - Root-tier recording samples shared tracing skips from the programs executing through active links.
Receipts and views reportbpf-trampoline-miss/shared-buildas shared skipped executions, with incomplete
coverage, rather than known lost events. Missing, changed or unreadable attachments/counters report uncertainty;
skips may belong to other runs or ungoverned tasks, and overlapping runs may count the same skip. Preemptible
kernels can still lose records (GAPS C53). - Built-in
.envrename refusals andtego learnexplain root-tier pip's name-coverage limit (C55) and its
measured contract/cwd remedy in OPERATIONS.md.
Write entries alone add no name coverage; pip's copy fallback can exit 0 while recording rename refusals. - Kernel-matrix guests prepare delegation and authenticated Unix diagnostics/loop modules; doctor-only checks
accept combined remedies. Automount tests use the same kernel's native result, and conformance releases
compile-only fixture trees before kernel tests. The 6.1 plane retains its probe reader and kernel minimum. - Protected host-server paths that the invoking user cannot traverse no longer prevent startup; reachable
objects remain pinned and unexpected identity errors still refuse launch. Compiled built-in entry names stay
the same when host servers are installed or removed. - Native Unix peer checks use the correct kernel-memory reader, and protected-name walks keep the original
verifier instruction budget across kernels. - Permitted overlay copy-up can use kernel-installed filesystem credentials without granting the agent
CAP_SYS_ADMIN; task-initiated mount changes and trusted xattr operations, including through an io_uring
personality, remain refused. Missing kernel bind/listen metadata is explicitly disclosed instead of inferred
from a copied attempt. Frozen bind lookup errors keep supervisor ownership and one observed result with their
actual errno. - Interactive Claude examples use short private session socket paths, check the complete path at launch and
refuse an overlong path with a fix. PTY peer delivery checks filesystem policy, live blocks and gates without
changing the supervisor's controlling terminal. - Developer correctness tests synchronize with observed readiness, lock state and peer admission, and bound Unix
socket fixture paths. Fast-path timing tests retain their original uninstrumented budgets in
scripts/timing-budgets.sh, with separate instrumented unit/race ceilings; production limits are unchanged.
The VM matrix, run by hand before a release, requires live SELinux/Smack policy fixtures without skips;
per-PR CI omits these proofs. - Dashboard event windows, indexes and pending asks have bounded retained state, with partial-history labels and
explicit truncation. Full-ledger receipts report a limit error rather than an incomplete unanswered-ask count.
Historical reads may rescan disk; these budgets are not a process memory cap. - Dashboard live regions retry after a failed refresh even if no new event arrives. Watched-run comparisons
require matching workspace and agent identity, preserving warnings when that identity is absent or different. - Receipts, dashboard verdicts and learned rules keep successful read/send pairs together; an unrelated refusal
no longer creates a leak warning. Proximity remains a heuristic. Newly written refusal/mirror pairs are
contiguous, and created-link and unanswered-ask totals agree across views; older displaced mirrors can remain
ambiguous. - Fresh agent setup generates explicit, portable Claude print-mode and Codex contracts without seeding
credentials. Codex settings-source notes appear in compile and verbose output, keeping ordinary starts quiet. - Agent selec...
v0.1.1-rc.1
This is a release candidate for v0.1.1, with the changes listed under v0.1.1 in docs/CHANGELOG.md. It exists to
rehearse the release run: signed binaries, the container image and the published notes. Use v0.1.0, or wait for
v0.1.1, unless you are testing the release itself.
Record v
1 (spec/record/v1, record minor 29)
Contract schema
0 (spec/agent/v0; the field set may change without notice before v0.2.0, docs/VERSIONING.md section 3)
Kernel minimums
Linux 5.14 with Landlock ABI 2 or newer, which is Linux 5.19 or a backport such as RHEL 9's 5.14; tested from 6.1 and on
RHEL 9 (tier 1: ABI 1 is unsupported, and features are gated per ABI, see spec/backend/CAPABILITIES.md;
tier 2 needs root and cgroup v2; tier 3 needs root and bpf in the LSM list). A unix socket under an fs.write path is
admitted without a unix: entry only with the kernel's socket diagnostics for AF_UNIX (CONFIG_UNIX_DIAG, built in
or the loadable unix_diag module); without them such a socket is refused unix-origin-unread, and tego doctor says so.
Syscall outcome hooks require readable tracefs event formats with an eight-byte ret at offset 16; unsupported
or unverified layouts withhold root tiers. The kernel version minimum is unchanged.
Container image
ghcr.io/attention-span-ai/tego@sha256:7dde984630a1e81cfa10c73d12c3ae8a4457dbed3d59d712efa289c9b3258370 (linux/amd64, linux/arm64).
v0.1.0
The first release. Tego runs an AI coding agent under a contract you write, a YAML file of rules for files, programs
and network hosts, and enforces it from outside the agent: the Linux kernel and Tego's supervisor refuse what the
contract rules out, can hold an action until you answer, and keep a hash-chained record of every run. Tego runs on
Linux (amd64 and arm64); on macOS and Windows it runs inside a Linux VM. It sends nothing home and never calls a model
itself.
Install
- Linux:
curl -fsSL https://github.com/Attention-Span-AI/Tego/releases/latest/download/install.sh | shinstalls
tegoandtego-controlinto~/.local/bin, checks them against the release's checksums, and checks who published
them whencosignor a logged-inghis onPATH. - macOS:
limactl start --name=tego https://github.com/Attention-Span-AI/Tego/releases/latest/download/tego.yaml
starts an Ubuntu 24.04 VM with Tego installed (brew install limafirst). - Windows:
wsl --install -d Ubuntu-24.04, then the Linux line inside Ubuntu. - From source:
make build(Go 1.27).docs/INSTALL.mdhas every route and what each was tested on.
Added
Contracts
tego initwrites a starter contract, from the built-in presetsno-secrets,no-prodandrepo-only-writeswith
--preset;tego compilechecks one and prints its rule table, and--testasks what each tier would do with an
action;tego learnproposes a contract from what a finished run did. Revision 1 of each preset is frozen from this
release on.- Rules for files (
fs), programs (exec), network hosts and ports (net), environment variables and limits (tokens,
cost, time, stalls, repeats, memory, processes). A run that passes a limit ends with exit code 124.
Three enforcement tiers, all in the release binary
- Tier 1 (
landlock), no root: Landlock and a seccomp supervisor. The kernel refuses writes and programs outside the
contract; Tego's supervisor decides network hosts. - Tier 2 (
cgroup), root: BPF programs attached to the run's cgroup, and fanotify. Hosts are decided in the kernel. - Tier 3 (
bpflsm), root, on a machine withbpfin the boot LSM list: BPF LSM hooks. tego doctorsays which tier a machine gets and prints a fix for each gap;tego testshows four harmless actions
refused at that tier, with no root and no agent.
Live rules and approvals
- An
askrule holds a file open or a connection until you answer withtego approveortego deny, or in the
dashboard. Held file reads (fs.ask_read) are tier 1 only;exec.askis reserved and refuses. - A running run can be paused, resumed, stopped and blocked (
tego pause,resume,stop,block,unblock), and
tego ruleturns something a run did into a rule. A run in the Adjustable live mode (tiers 2 and 3) can also be
loosened while it runs (docs/user/live-modes.md). - MCP tool rules: a relay allows, holds or denies single tools of an MCP server, and
tego mcpchanges that live.
The record
- Every run writes a hash-chained record, anchored in
~/.tego/chain.log.tego receiptsummarises a run,tego events
prints it andtego events <run> --verifychecks its chain,tego driftcompares what was allowed with what was
used, andtego measurecounts steps, tokens, cost and time. What the record holds depends on the tier: by default
tier 1 records programs, writes and connections, and no file reads (record: fullrecords reads).
The dashboard
tego serve --openserves a dashboard on127.0.0.1:8484for one person: runs, logs, refusals, held requests to allow
or deny, each run's rules, and stop, pause and block. It runs astego-control, which refuses to run as root.
The agent watcher
tego watchruns any command as a black box and records what it does.tego agentslists the agent processes
running on the machine andtego adoptmoves one that is already running into a governed run; both need root.
Supported agents
examples/agents/has contracts for Claude Code (print mode and the full-screen interface), OpenAI Codex (API key
through Tego's forwarder, or a ChatGPT sign-in), a Python agent on the Claude Agent SDK, one on the Anthropic Python
SDK, a Python retriever with one MCP server, and an agent of your own left to run unattended. Any other agent is an
ordinary process: write a contract for it, or start withtego watch.
Release
- Static binaries for Linux amd64 and arm64, with the tier-2 and tier-3 BPF objects built in. The checksums file is
signed with cosign (keyless, by this repository's release workflow at this tag) and every file it lists has a build
provenance attestation; the binaries are built again from the tag on a fresh runner and must match byte for byte
before the release is published.install.shand the macOS templatetego.yamlare release assets too, in the same
checksums file, and the one-line installs take them from the latest release.tego_0.1.0_licenses.tar.gzholds the
licence texts, andtego licensesprints them.
Security
Fixed since the source was first published on 2026-11-02.
- In fmod_ret plane mode the kernel could skip a deciding program on a CPU where a preempted task was still inside it,
and the hooked call then went ahead undecided: on kernels that preempt kernel code (full or lazy preemption, the
default on 7.0 kernels) an agent could open files its contract denies. A release build now uses fmod_ret mode only
where the kernel provably cannot preempt kernel code (a fixed none or voluntary build, or a dynamic build whose
debugfs mode says none or voluntary, read again at every run and adoption); elsewheretego doctorsays why and
tier cgroup uses LSM mode or the fanotify listener. Hosts whose debugfs cannot be read (for example under Secure
Boot lockdown) no longer get fmod_ret mode. - A contract endpoint written with a mixed-case scheme (
uniX:0) passed as a host name and skipped the Unix socket
path checks; selectors must now be lowercase. - At tier landlock an agent could open a
deny_writefile such as.git/configfor writing through a symlink whose
body goes through its own/proc/self/task/<tid>and climbs back out. The supervisor now resolves such a link the
way the agent's own lookup does, and the open is refused. - A run with a
net:section can no longer source-route around its contract:setsockoptofIP_OPTIONS,
IPV6_RTHDR,IPV6_2292RTHDRandIPV6_2292PKTOPTIONSfailsEPERM, and a datagram whose control message routes it
is refused with arelay-source-routedline (GAPS C34). - The built-in
deny_readlist also refuses the desktop keyrings,~/.my.cnf,~/.mylogin.cnf,~/.s3cfg,~/.boto,
rclone's config, the RubyGems and Composer credentials,~/.m2/settings-security.xml, and the doctl, hub, glab,
flyctl, Supabase and OCI CLI stores.
Fixed
Since the source was first published on 2026-11-02.
- Set up a new agent takes a long form and keeps a comment on the name line; removing an entry listed twice removes
both;tego rulechanges read in words in the dashboard's history and undo the right way. tego gcand the retention pass prune the rule-change journal, keeping everything a run in the ledger root still
reads and each rules file's newest 20 standing changes.- The Block now terminal line fills in what the form holds, quoted, and keeps a selection.
- A run can no longer watch what it may not read: inotify, fanotify and dnotify watches of a
deny_readtarget are
refused. - Live blocks, gate rules and the model guard read this host the same way, local routes included (AnyIP ranges,
hand-set broadcast and IPv6 anycast addresses). tego init --presetmakes a preset's folders with no link followed, and works inside a tego run.- An agent that runs
chmod 000on tego's own files no longer makes its run fail or refuses the runs after it; tego
gives the owner back the rights it needs, andtego gcdeletes nothing by a config layer it cannot read. - The dashboard reads a run whose launcher died as Lost within a few seconds, re-checks a cached chain verdict, and
keeps a live host block's addresses fresh. - tego block notes a program whose file has other names (a multi-call coreutils or busybox) and a bare name on no
PATH folder; the dashboard's Remove on an ended run is refused as tego unblock is. - The CLI's record views count a refusal once when its mirror line is not next to it, as the dashboard does.
- tego rule and the dashboard's previews warn when a host a change adds does not resolve.
- tego help marks the commands that need root;
tego-control serve --addrtakes [::1]; error pages keep the live
chrome; file rows offer Block;compile --testsays which tiers auto leaves out and why. - tego run's end line names the tier, and every command that takes a run accepts a unique abbreviation of its id; a
bare short name is no longer read as a local run directory (use ./name). - The Rules page lists the machine's limit ceilings, net.http, ingress and gate rules and the tier-1 datagram residual,
counts what the defaults decided, and counts every name of a program's file, git's helpers and a script's interpreter. - Logs and the line page say "Watched only" for a watched run's lines.
- The line page streams a blob download instead of holding it in memory.
- The demo kit runs under a pyenv or asdf python3 shim and says when a run did not start; the supply-chain demo's proof
readstego events --json, and its reset never deletes a folder it did not move. - tego watch and tego adopt name themselves in the run path's messages.
- Logs: the
path:query key matches whole names, sopath:/a/bno longer lists/a/bc. - The dashboard words six refusal reasons it showed as bare codes (MCP tool blocked, Sandbox boundary, and the
credential and model-route codes). - Never allow from a Deny on a connection opens that connection's own refusal; Make it perman...