Zeline v0.4.2

Zeline v0.4.2

Zeline is the open-source agentic AI framework by Zerolinear.

This release brings the reviewed runtime and Telegram improvements on main
into a versioned distribution. It builds on the retained v0.3.4 baseline; it is
not a wholesale restoration of the removed v0.3.5–v0.3.9 code line.

Highlights

• Terminal runtime dashboard and chat composer. Responsive paired panels,
  readable narrow-terminal fallback, local command handling, live tool activity,
  gateway/QR presentation, and PTY coverage keep the operator view stable
  without echoing sensitive tool arguments.

• Safer staged updater. Update plans now show the target and verification
  stages, verify SHA-256 before installation, bound release payloads, and always
  restore a paused gateway when verification or installer startup fails.

• Bounded local discovery. Loopback 9Router probing and parallel MCP discovery
  use explicit deadlines and bounded reads so an unavailable optional service
  cannot stall the runtime indefinitely.

• Bounded, resumable tool I/O. Read files in bounded pages, resume with
  validated cursors, and preserve complete process output in bounded spools.
  Invalid UTF-8 and incomplete capture remain visible failures rather than
  silently truncated success. Process ownership and cleanup respect cancellation.

• Evidence-preserving context. Session compaction and stored context windows
  retain tool-call/result integrity and continuation evidence rather than merely
  trimming the newest messages.

• Safer self-improvement. Internal reflection proposes skill changes instead
  of silently overwriting or deleting active procedures. SkillForge supports
  observed usage, revision proposals, test gates, explicit review and backups.
  Routine operator-requested skill management remains available.

• Truthful learning phases. 📙 Self-Enhancement, 📘 Self-Improvement and
  📗 Self-Refinement are emitted only for supported actions and evidence. Empty,
  cancelled or failed reviews do not fabricate completed phases; incomplete
  reviews remain visible. Substantial research can qualify for review.

• Updated Telegram activity UI. Restored activity icons, including
  📂 Executing browser script…, compact letter-choice questions with durable
  receipts, separate post-task learning messages, unquoted live narration,
  preserved final-answer attribution and explicit stop confirmation. Progress
  favors findings, blockers and decisions over repetitive routine narration.

• Runtime and cron hardening. Reviewed execution-policy, cancellation,
  continuation and scheduler fixes, including macOS cleanup race handling.
  Subprocess cleanup never group-signals a shared or foreign group; owned
  descendants and Windows tree termination retain their cleanup behavior.
  This defensive fix does not establish the cause of any past host outage.

• Optional MCP integrations. Documented Parallel Search and local Sem code
  lookup. These are optional external servers, not new built-in runtime tools;
  their access and side effects are documented in the integration guide.

Verification

The integrated core passed the complete configured CI matrix, including
Python 3.10–3.13, Windows and macOS. Release metadata, installers, source
archives and wheel contents are checked again for this version. The release
workflow verifies checksums and bundled assets and generates build provenance.
PyPI uses Trusted Publishing (OIDC), not a long-lived API token stored in this
repository. GitHub Actions uploads the verified distributions without rebuilding.

Install or upgrade

PyPI, inside a virtual environment:

python -m pip install --upgrade zeline==0.4.2

Or install in an isolated tool environment:

uv tool install zeline==0.4.2

POSIX installer — Termux, Linux, macOS and iSH:

curl -fsSLO --proto '=https' --tlsv1.2 https://github.com/Mftrferdinand/Zeline/releases/download/v0.4.2/install.sh && bash install.sh

Windows PowerShell:

iwr -UseBasicParsing https://github.com/Mftrferdinand/Zeline/releases/download/v0.4.2/install.ps1 -OutFile install.ps1; .\install.ps1

The installers download the matching versioned wheel and verify its SHA-256
checksum. Run zeline setup after a new install. Existing installations can use
zeline update, or /update in Telegram.

Upgrade notes

• Back up your existing configuration before upgrading. No manual configuration
  migration is required by this release; explicit operator settings are retained.
• Live code changes require a gateway restart. The updater drains active work
  and preserves the gateway selection. Updating a source checkout alone does
  not update a separately installed launcher environment.
• The mobile app remains a separate product and release cycle.
• This release does not claim to eliminate all bugs or provider/network errors.

Documentation

• Installation guide
• Changelog
• Bounded runtime I/O
• Optional MCP setup

Release assets

• zeline-0.4.2-py3-none-any.whl
• zeline-0.4.2.tar.gz
• install.sh and install.ps1
• SHA256SUMS

Artifacts are built from the immutable release tag in merged main history.
GitHub Release and PyPI receive the same wheel and source archive.

Agent-generated release notes.

Zeline v0.4.1

Zeline v0.4.1

Zeline is the open-source agentic AI framework by Zerolinear.

This release brings the reviewed runtime and Telegram improvements on main
into a versioned distribution. It builds on the retained v0.3.4 baseline; it is
not a wholesale restoration of the removed v0.3.5–v0.3.9 code line.

Highlights

• Bounded, resumable tool I/O. Read files in bounded pages, resume with
  validated cursors, and preserve complete process output in bounded spools.
  Invalid UTF-8 and incomplete capture remain visible failures rather than
  silently truncated success. Process ownership and cleanup respect cancellation.
• Evidence-preserving context. Session compaction and stored context windows
  retain tool-call/result integrity and continuation evidence rather than merely
  trimming the newest messages.
• Safer self-improvement. Internal reflection proposes skill changes instead
  of silently overwriting or deleting active procedures. SkillForge supports
  observed usage, revision proposals, test gates, explicit review and backups.
  Routine operator-requested skill management remains available.
• Truthful learning phases. 📙 Self-Enhancement, 📘 Self-Improvement and
  📗 Self-Refinement are emitted only for supported actions and evidence. Empty,
  cancelled or failed reviews do not fabricate completed phases; incomplete
  reviews remain visible. Substantial research can qualify for review.
• Updated Telegram activity UI. Restored activity icons, including
  📂 Executing browser script…, compact letter-choice questions with durable
  receipts, separate post-task learning messages, unquoted live narration,
  preserved final-answer attribution and explicit stop confirmation. Progress
  favors findings, blockers and decisions over repetitive routine narration.
• Runtime and cron hardening. Reviewed execution-policy, cancellation,
  continuation and scheduler fixes, including macOS cleanup race handling.
  Subprocess cleanup never group-signals a shared or foreign group; owned
  descendants and Windows tree termination retain their cleanup behavior.
  This defensive fix does not establish the cause of any past host outage.
• Optional MCP integrations. Documented Parallel Search and local Sem code
  lookup. These are optional external servers, not new built-in runtime tools;
  their access and side effects are documented in the integration guide.

Verification

The integrated core passed the complete configured CI matrix, including
Python 3.10–3.13, Windows and macOS. Release metadata, installers, source
archives and wheel contents are checked again for this version. The release
workflow verifies checksums and bundled assets and generates build provenance.
PyPI uses Trusted Publishing (OIDC), not a long-lived API token stored in this
repository. GitHub Actions uploads the verified distributions without rebuilding.

Install or upgrade

PyPI, inside a virtual environment:

python -m pip install --upgrade zeline==0.4.1

Or install in an isolated tool environment:

uv tool install zeline==0.4.1

POSIX installer — Termux, Linux, macOS and iSH:

curl -fsSLO --proto '=https' --tlsv1.2 https://github.com/Mftrferdinand/Zeline/releases/download/v0.4.1/install.sh && bash install.sh

Windows PowerShell:

iwr -UseBasicParsing https://github.com/Mftrferdinand/Zeline/releases/download/v0.4.1/install.ps1 -OutFile install.ps1; .\install.ps1

The installers download the matching versioned wheel and verify its SHA-256
checksum. Run zeline setup after a new install. Existing installations can use
zeline update, or /update in Telegram.

Upgrade notes

• Back up your existing configuration before upgrading. No manual configuration
  migration is required by this release; explicit operator settings are retained.
• Live code changes require a gateway restart. The updater drains active work
  and preserves the gateway selection. Updating a source checkout alone does
  not update a separately installed launcher environment.
• The mobile app remains a separate product and release cycle.
• This release does not claim to eliminate all bugs or provider/network errors.

Documentation

• Installation guide
• Changelog
• Bounded runtime I/O
• Optional MCP setup

Release assets

• zeline-0.4.1-py3-none-any.whl
• zeline-0.4.1.tar.gz
• install.sh and install.ps1
• SHA256SUMS

Artifacts are built from the immutable release tag in merged main history.
GitHub Release and PyPI receive the same wheel and source archive.

Agent-generated release notes.

Zeline v0.3.2

Zeline Release

Zeline is the open-source agentic AI framework by Zerolinear.

Installing

PyPI (recommended):

pip install zeline
# or, in an isolated tool environment:
uv tool install zeline

Then zeline setup.

One line on every POSIX platform — Termux, Linux, macOS, iSH:

curl -fsSLO --proto '=https' --tlsv1.2 https://github.com/Mftrferdinand/Zeline/releases/download/v0.3.2/install.sh && bash install.sh

The installer downloads the versioned wheel and verifies it against
SHA256SUMS itself, so there is nothing to check by hand.

Every release carries the whole bundled surface — this one ships 255 skills
(109 of them the Zenith corpus) and 29 tools — and the release workflow now
diffs the built wheel against the source tree and fails rather than publishing an
install that is missing any of it.

Highlights

• The live Telegram feed names the work, not the function. Eight of the
  twenty-nine registered tools had no label and fell through to a catch-all that
  printed the raw tool name: 🔧 recall history: lanjut, 🔧 browser: open,
  🔧 code intel: diagnostics, 🔧 download file: <full URL>. That is a debug
  dump. runtime_info now reads as a runtime identity check, browser and
  code_intel get a verb per action plus the page host or the file and line, and
  download_file names the destination. URLs are reduced to their host, because a
  raw URL can carry a query token or user:pass@host credentials. MCP tools were
  also hitting the fallback, whose underscore substitution produced
  🔧 mcp mem0 add memory; they render as 🧩 add memory via mem0.
• /stop lands in under 0.1 s, down from up to 180 s. Cancellation used to be
  a flag the agent could only notice between provider calls, so a stop issued
  during a blocking request waited for that request to return. It now closes the
  in-flight response and its socket, and checks cancellation before a request
  goes out and inside the model-failover loop.
• A long task is no longer cut off at ten edit cycles. max_tool_rounds
  defaults to 150 (was 20) and max_turn_seconds to 4500 (was 1800). Twenty
  rounds is about ten read-then-edit cycles, which a multi-file change exhausts
  before it is done; the clock stays above rounds × 30 s so the round budget is
  the real limit and the clock is a backstop for a genuinely stuck turn.
• The activity feed is one compact line per command. A stack of tall code
  cards with COPY CODE buttons is replaced by a single one-line card: no nested
  language label, content flattened and capped, and the cut placed at the last
  word boundary so a command reads as abbreviated rather than severed.
• Narration speaks for findings, not for every step. The old prompt mandated
  an opener plus a sentence per tool batch, which produced a running commentary of
  trivial mechanical actions. Routine reads and greps now happen silently.
• lanjut resumes the session you are actually in. Continuation resolved to
  the newest turns sharing the newest title, so a fresh session whose title
  matched an older bucket recalled the previous day's work as if it were still in
  progress.
• Bundled skills work for whoever installed Zeline. Several shipped with
  hardcoded personal paths, accounts, and site names, so for every other user
  they failed on the first command or pointed somewhere irrelevant.
• Model discovery no longer assumes one response shape. /models,
  /v1/models, and /api/tags are each tried, and data, models,
  data_list, and bare list payloads all parse.
• A release no longer reports failure because PyPI has no Trusted Publisher.
  Publishing goes through Trusted Publishing (OIDC), so no API token is stored in
  this repository — but a publisher lives in a PyPI account the workflow cannot
  see, and the upload used to fail with invalid-publisher on every release and
  paint the pypi deployment red for a release whose assets were built,
  verified, attested, and published. The upload is now gated on a probe that asks
  PyPI whether it accepts this workflow's identity, so the job is skipped with
  setup instructions when no publisher exists and runs normally once one does. A
  skipped job says "not configured"; a failed job says "broken". With the
  publisher now registered, pip install zeline and uv tool install zeline
  are supported from this release onward.
• zeline update restarts the gateways that were actually running. It read
  the selection after the stop had already deleted the state file, so an operator
  who started only Telegram got every enabled gateway back.

For contributors

CONTRIBUTING.md now documents the fork-and-pull-request path. Its opening
instruction used to be git push -u origin <branch> against this repository,
which fails with 403 for anyone without push access, and the word "fork" appeared
nowhere in it or in any README. ZELINE.md is this repository's project
conventions — layout, real build and test commands, commit style, what not to
commit — rather than a persona document, with every claim checked against the tree.

Removed

The mobile-app HTTP surface has moved out of this repository. The framework ships
the agent runtime and the messaging gateways that adapt it to a chat platform; the
app's REST/SSE server, session store, JWT auth, and client event schema are a
separate product with a separate release cycle, and keeping them here made a
framework release gate on an app change. Nothing the CLI or the messaging gateways
use is affected; a gateways.zeline_app entry left in an existing config.json
is inert.

Security

Custom tools, plugin hooks, and MCP stdio servers are arbitrary local Python in
the agent's process and load only on the workspace/full profiles — a public
gateway on safe never reaches them. Provider API keys never appear in any
response, and the progress feed prints a URL's host only, never the full URL or a
proxy's credentials.

Upgrade note

No configuration changes are required. Existing installs can upgrade in place
with zeline update, or /update from Telegram. If you had raised
agent.max_tool_rounds yourself, your value is kept — the change is to the
default for installs that never set it.

Installation

See the installation guide for install commands on every supported platform, and the changelog for the full list of changes with links to every pull request.

Assets

• POSIX installer: install.sh
• Windows installer: install.ps1
• Python wheel and source archive
• SHA256SUMS

All assets are built from merged main, checksum-verified, and published with build provenance.

Zeline v0.3.1

Zeline Release

Zeline is the open-source agentic AI framework by Zerolinear.

Installing

PyPI (recommended):

pip install zeline
# or, in an isolated tool environment:
uv tool install zeline

Then zeline setup.

One line on every POSIX platform — Termux, Linux, macOS, iSH:

curl -fsSLO --proto '=https' --tlsv1.2 https://github.com/Mftrferdinand/Zeline/releases/download/v0.3.1/install.sh && bash install.sh

The installer downloads the versioned wheel and verifies it against
SHA256SUMS itself, so there is nothing to check by hand. Node.js users can
also run npm install -g zeline; the npm wrapper verifies the same wheel and
installs it into the same private runtime.

Every release carries the whole bundled surface — this one ships 255 skills
(109 of them the Zenith corpus) and 29 tools — and the release workflow now
diffs the built wheel against the source tree and fails rather than publishing an
install that is missing any of it.

Highlights

• The live Telegram feed names the work, not the function. Eight of the
  twenty-nine registered tools had no label and fell through to a catch-all that
  printed the raw tool name: 🔧 recall history: lanjut, 🔧 browser: open,
  🔧 code intel: diagnostics, 🔧 download file: <full URL>. That is a debug
  dump. runtime_info now reads as a runtime identity check, browser and
  code_intel get a verb per action plus the page host or the file and line, and
  download_file names the destination. URLs are reduced to their host, because a
  raw URL can carry a query token or user:pass@host credentials. MCP tools were
  also hitting the fallback, whose underscore substitution produced
  🔧 mcp mem0 add memory; they render as 🧩 add memory via mem0.
• /stop lands in under 0.1 s, down from up to 180 s. Cancellation used to be
  a flag the agent could only notice between provider calls, so a stop issued
  during a blocking request waited for that request to return. It now closes the
  in-flight response and its socket, and checks cancellation before a request
  goes out and inside the model-failover loop.
• A long task is no longer cut off at ten edit cycles. max_tool_rounds
  defaults to 150 (was 20) and max_turn_seconds to 4500 (was 1800). Twenty
  rounds is about ten read-then-edit cycles, which a multi-file change exhausts
  before it is done; the clock stays above rounds × 30 s so the round budget is
  the real limit and the clock is a backstop for a genuinely stuck turn.
• The activity feed is one compact line per command. A stack of tall code
  cards with COPY CODE buttons is replaced by a single one-line card: no nested
  language label, content flattened and capped, and the cut placed at the last
  word boundary so a command reads as abbreviated rather than severed.
• Narration speaks for findings, not for every step. The old prompt mandated
  an opener plus a sentence per tool batch, which produced a running commentary of
  trivial mechanical actions. Routine reads and greps now happen silently.
• lanjut resumes the session you are actually in. Continuation resolved to
  the newest turns sharing the newest title, so a fresh session whose title
  matched an older bucket recalled the previous day's work as if it were still in
  progress.
• Bundled skills work for whoever installed Zeline. Several shipped with
  hardcoded personal paths, accounts, and site names, so for every other user
  they failed on the first command or pointed somewhere irrelevant.
• Model discovery no longer assumes one response shape. /models,
  /v1/models, and /api/tags are each tried, and data, models,
  data_list, and bare list payloads all parse.
• A release no longer reports failure because PyPI has no Trusted Publisher.
  Publishing goes through Trusted Publishing (OIDC), so no API token is stored in
  this repository — but a publisher lives in a PyPI account the workflow cannot
  see, and the upload used to fail with invalid-publisher on every release and
  paint the pypi deployment red for a release whose assets were built,
  verified, attested, and published. The upload is now gated on a probe that asks
  PyPI whether it accepts this workflow's identity, so the job is skipped with
  setup instructions when no publisher exists and runs normally once one does. A
  skipped job says "not configured"; a failed job says "broken". With the
  publisher now registered, pip install zeline and uv tool install zeline
  are supported from this release onward.
• zeline update restarts the gateways that were actually running. It read
  the selection after the stop had already deleted the state file, so an operator
  who started only Telegram got every enabled gateway back.

For contributors

CONTRIBUTING.md now documents the fork-and-pull-request path. Its opening
instruction used to be git push -u origin <branch> against this repository,
which fails with 403 for anyone without push access, and the word "fork" appeared
nowhere in it or in any README. ZELINE.md is this repository's project
conventions — layout, real build and test commands, commit style, what not to
commit — rather than a persona document, with every claim checked against the tree.

Removed

The mobile-app HTTP surface has moved out of this repository. The framework ships
the agent runtime and the messaging gateways that adapt it to a chat platform; the
app's REST/SSE server, session store, JWT auth, and client event schema are a
separate product with a separate release cycle, and keeping them here made a
framework release gate on an app change. Nothing the CLI or the messaging gateways
use is affected; a gateways.zeline_app entry left in an existing config.json
is inert.

Security

Custom tools, plugin hooks, and MCP stdio servers are arbitrary local Python in
the agent's process and load only on the workspace/full profiles — a public
gateway on safe never reaches them. Provider API keys never appear in any
response, and the progress feed prints a URL's host only, never the full URL or a
proxy's credentials.

Upgrade note

No configuration changes are required. Existing installs can upgrade in place
with zeline update, or /update from Telegram. If you had raised
agent.max_tool_rounds yourself, your value is kept — the change is to the
default for installs that never set it.

Installation

See the installation guide for install commands on every supported platform, and the changelog for the full list of changes with links to every pull request.

Assets

• POSIX installer: install.sh
• Windows installer: install.ps1
• Python wheel and source archive
• SHA256SUMS

All assets are built from merged main, checksum-verified, and published with build provenance.

Zeline v0.3.0

Zeline Release

Zeline is the open-source agentic AI framework by Zerolinear.

Installing

One line on every POSIX platform — Termux, Linux, macOS, iSH:

curl -fsSLO --proto '=https' --tlsv1.2 https://github.com/Mftrferdinand/Zeline/releases/download/v0.3.0/install.sh && bash install.sh

The installer downloads the versioned wheel and verifies it against
SHA256SUMS itself, so there is nothing to check by hand.

Every release carries the whole bundled surface — this one ships 255 skills
(109 of them the Zenith corpus) and 29 tools — and the release workflow now
diffs the built wheel against the source tree and fails rather than publishing an
install that is missing any of it.

Highlights

• The live Telegram feed names the work, not the function. Eight of the
  twenty-nine registered tools had no label and fell through to a catch-all that
  printed the raw tool name: 🔧 recall history: lanjut, 🔧 browser: open,
  🔧 code intel: diagnostics, 🔧 download file: <full URL>. That is a debug
  dump. runtime_info now reads as a runtime identity check, browser and
  code_intel get a verb per action plus the page host or the file and line, and
  download_file names the destination. URLs are reduced to their host, because a
  raw URL can carry a query token or user:pass@host credentials. MCP tools were
  also hitting the fallback, whose underscore substitution produced
  🔧 mcp mem0 add memory; they render as 🧩 add memory via mem0.
• /stop lands in under 0.1 s, down from up to 180 s. Cancellation used to be
  a flag the agent could only notice between provider calls, so a stop issued
  during a blocking request waited for that request to return. It now closes the
  in-flight response and its socket, and checks cancellation before a request
  goes out and inside the model-failover loop.
• A long task is no longer cut off at ten edit cycles. max_tool_rounds
  defaults to 150 (was 20) and max_turn_seconds to 4500 (was 1800). Twenty
  rounds is about ten read-then-edit cycles, which a multi-file change exhausts
  before it is done; the clock stays above rounds × 30 s so the round budget is
  the real limit and the clock is a backstop for a genuinely stuck turn.
• The activity feed is one compact line per command. A stack of tall code
  cards with COPY CODE buttons is replaced by a single one-line card: no nested
  language label, content flattened and capped, and the cut placed at the last
  word boundary so a command reads as abbreviated rather than severed.
• Narration speaks for findings, not for every step. The old prompt mandated
  an opener plus a sentence per tool batch, which produced a running commentary of
  trivial mechanical actions. Routine reads and greps now happen silently.
• lanjut resumes the session you are actually in. Continuation resolved to
  the newest turns sharing the newest title, so a fresh session whose title
  matched an older bucket recalled the previous day's work as if it were still in
  progress.
• Bundled skills work for whoever installed Zeline. Several shipped with
  hardcoded personal paths, accounts, and site names, so for every other user
  they failed on the first command or pointed somewhere irrelevant.
• Model discovery no longer assumes one response shape. /models,
  /v1/models, and /api/tags are each tried, and data, models,
  data_list, and bare list payloads all parse.
• A release no longer reports failure because PyPI has no Trusted Publisher.
  Publishing goes through Trusted Publishing (OIDC), so no API token is stored in
  this repository — but a publisher lives in a PyPI account the workflow cannot
  see, and the upload used to fail with invalid-publisher on every release and
  paint the pypi deployment red for a release whose assets were built,
  verified, attested, and published. The upload is now gated on a probe that asks
  PyPI whether it accepts this workflow's identity, so the job is skipped with
  setup instructions when no publisher exists and runs normally once one does. A
  skipped job says "not configured"; a failed job says "broken". pip/uv
  installs become available with the first release whose upload completes; until
  then use the installer above.
• zeline update restarts the gateways that were actually running. It read
  the selection after the stop had already deleted the state file, so an operator
  who started only Telegram got every enabled gateway back.

For contributors

CONTRIBUTING.md now documents the fork-and-pull-request path. Its opening
instruction used to be git push -u origin <branch> against this repository,
which fails with 403 for anyone without push access, and the word "fork" appeared
nowhere in it or in any README. ZELINE.md is this repository's project
conventions — layout, real build and test commands, commit style, what not to
commit — rather than a persona document, with every claim checked against the tree.

Removed

The mobile-app HTTP surface has moved out of this repository. The framework ships
the agent runtime and the messaging gateways that adapt it to a chat platform; the
app's REST/SSE server, session store, JWT auth, and client event schema are a
separate product with a separate release cycle, and keeping them here made a
framework release gate on an app change. Nothing the CLI or the messaging gateways
use is affected; a gateways.zeline_app entry left in an existing config.json
is inert.

Security

Custom tools, plugin hooks, and MCP stdio servers are arbitrary local Python in
the agent's process and load only on the workspace/full profiles — a public
gateway on safe never reaches them. Provider API keys never appear in any
response, and the progress feed prints a URL's host only, never the full URL or a
proxy's credentials.

Upgrade note

No configuration changes are required. Existing installs can upgrade in place
with zeline update, or /update from Telegram. If you had raised
agent.max_tool_rounds yourself, your value is kept — the change is to the
default for installs that never set it.

Installation

See the installation guide for install commands on every supported platform, and the changelog for the full list of changes with links to every pull request.

Assets

• POSIX installer: install.sh
• Windows installer: install.ps1
• Python wheel and source archive
• SHA256SUMS

All assets are built from merged main, checksum-verified, and published with build provenance.

Zeline v0.2.9

Zeline Release

Zeline is the open-source agentic AI framework by Zerolinear.

Installing

One line on every POSIX platform — Termux, Linux, macOS, iSH:

curl -fsSLO --proto '=https' --tlsv1.2 https://github.com/Mftrferdinand/Zeline/releases/download/v0.2.9/install.sh && bash install.sh

The installer downloads the versioned wheel and verifies it against
SHA256SUMS itself, so there is nothing to check by hand.

Every release carries the whole bundled surface — this one ships 255 skills
(109 of them the Zenith corpus) and 29 tools — and the release workflow now
diffs the built wheel against the source tree and fails rather than publishing an
install that is missing any of it.

Highlights

• The live Telegram feed names the work, not the function. Eight of the
  twenty-nine registered tools had no label and fell through to a catch-all that
  printed the raw tool name: 🔧 recall history: lanjut, 🔧 browser: open,
  🔧 code intel: diagnostics, 🔧 download file: <full URL>. That is a debug
  dump. runtime_info now reads as a runtime identity check, browser and
  code_intel get a verb per action plus the page host or the file and line, and
  download_file names the destination. URLs are reduced to their host, because a
  raw URL can carry a query token or user:pass@host credentials. MCP tools were
  also hitting the fallback, whose underscore substitution produced
  🔧 mcp mem0 add memory; they render as 🧩 add memory via mem0.
• /stop lands in under 0.1 s, down from up to 180 s. Cancellation used to be
  a flag the agent could only notice between provider calls, so a stop issued
  during a blocking request waited for that request to return. It now closes the
  in-flight response and its socket, and checks cancellation before a request
  goes out and inside the model-failover loop.
• A long task is no longer cut off at ten edit cycles. max_tool_rounds
  defaults to 150 (was 20) and max_turn_seconds to 4500 (was 1800). Twenty
  rounds is about ten read-then-edit cycles, which a multi-file change exhausts
  before it is done; the clock stays above rounds × 30 s so the round budget is
  the real limit and the clock is a backstop for a genuinely stuck turn.
• The activity feed is one compact line per command. A stack of tall code
  cards with COPY CODE buttons is replaced by a single one-line card: no nested
  language label, content flattened and capped, and the cut placed at the last
  word boundary so a command reads as abbreviated rather than severed.
• Narration speaks for findings, not for every step. The old prompt mandated
  an opener plus a sentence per tool batch, which produced a running commentary of
  trivial mechanical actions. Routine reads and greps now happen silently.
• lanjut resumes the session you are actually in. Continuation resolved to
  the newest turns sharing the newest title, so a fresh session whose title
  matched an older bucket recalled the previous day's work as if it were still in
  progress.
• Bundled skills work for whoever installed Zeline. Several shipped with
  hardcoded personal paths, accounts, and site names, so for every other user
  they failed on the first command or pointed somewhere irrelevant.
• Model discovery no longer assumes one response shape. /models,
  /v1/models, and /api/tags are each tried, and data, models,
  data_list, and bare list payloads all parse.
• A release no longer reports failure because PyPI has no Trusted Publisher.
  Publishing goes through Trusted Publishing (OIDC), so no API token is stored in
  this repository — but a publisher lives in a PyPI account the workflow cannot
  see, and the upload used to fail with invalid-publisher on every release and
  paint the pypi deployment red for a release whose assets were built,
  verified, attested, and published. The upload is now gated on a probe that asks
  PyPI whether it accepts this workflow's identity, so the job is skipped with
  setup instructions when no publisher exists and runs normally once one does. A
  skipped job says "not configured"; a failed job says "broken". pip/uv
  installs become available with the first release whose upload completes; until
  then use the installer above.
• zeline update restarts the gateways that were actually running. It read
  the selection after the stop had already deleted the state file, so an operator
  who started only Telegram got every enabled gateway back.

For contributors

CONTRIBUTING.md now documents the fork-and-pull-request path. Its opening
instruction used to be git push -u origin <branch> against this repository,
which fails with 403 for anyone without push access, and the word "fork" appeared
nowhere in it or in any README. ZELINE.md is this repository's project
conventions — layout, real build and test commands, commit style, what not to
commit — rather than a persona document, with every claim checked against the tree.

Removed

The mobile-app HTTP surface has moved out of this repository. The framework ships
the agent runtime and the messaging gateways that adapt it to a chat platform; the
app's REST/SSE server, session store, JWT auth, and client event schema are a
separate product with a separate release cycle, and keeping them here made a
framework release gate on an app change. Nothing the CLI or the messaging gateways
use is affected; a gateways.zeline_app entry left in an existing config.json
is inert.

Security

Custom tools, plugin hooks, and MCP stdio servers are arbitrary local Python in
the agent's process and load only on the workspace/full profiles — a public
gateway on safe never reaches them. Provider API keys never appear in any
response, and the progress feed prints a URL's host only, never the full URL or a
proxy's credentials.

Upgrade note

No configuration changes are required. Existing installs can upgrade in place
with zeline update, or /update from Telegram. If you had raised
agent.max_tool_rounds yourself, your value is kept — the change is to the
default for installs that never set it.

Installation

See the installation guide for install commands on every supported platform, and the changelog for the full list of changes with links to every pull request.

Assets

• POSIX installer: install.sh
• Windows installer: install.ps1
• Python wheel and source archive
• SHA256SUMS

All assets are built from merged main, checksum-verified, and published with build provenance.

Zeline v0.2.8

Zeline Release

Zeline is the open-source agentic AI framework by Zerolinear.

Installing

One line on every POSIX platform — Termux, Linux, macOS, iSH:

curl -fsSLO --proto '=https' --tlsv1.2 https://github.com/Mftrferdinand/Zeline/releases/download/v0.2.8/install.sh && bash install.sh

The installer downloads the versioned wheel and verifies it against
SHA256SUMS itself, so there is nothing to check by hand.

This release also carries the PyPI publishing pipeline: the workflow uploads
through Trusted Publishing (OIDC), with no API token stored in the repository,
and it publishes the exact artifacts that already passed checksum and metadata
verification rather than rebuilding — so the bytes on PyPI are the bytes attested
here. pip/uv installs become available with the first release whose upload
completes; until then use the installer above.

Highlights

• A turn is no longer cut short by a clock that could never agree with the
  round limit. The per-turn wall clock was a hardcoded 360 s while
  max_tool_rounds defaults to 20. One model call takes 7–50 s, so the clock
  always expired first: the round limit was unreachable and long multi-step
  tasks were interrupted mid-work and forced to summarise. The default is now
  1800 s — a backstop for a genuinely stuck turn rather than the work scheduler
  — and it is configurable with zeline setup agent.
• A local OpenAPI document becomes real tools. Point Zeline at an OpenAPI 3
  file and its operations load as namespaced api_* tools with schemas derived
  from the document, instead of hand-written wrappers that drift from the API.
  Credentials come from ~/.zeline/.env, never from the model-visible schema,
  and only workspace/full profiles load them.
• Self-improvement writes through a real skill surface. manage_skill
  replaces the old save-only path: create, patch, write_file, delete, and
  list. Skills are folders (SKILL.md plus references/, templates/,
  scripts/, assets/), a bundled skill is repaired by copy-on-write into a
  private override that survives upgrades, and a duplicate can be merged away
  with absorbed_into instead of accumulating three files for one lesson.
• A Discord bot no longer goes quiet after a reconnect. The keepalive thread
  closed over the reconnect loop's locals, so after a reconnect a thread from the
  dead connection wrote heartbeat frames to the new socket alongside the new
  thread. Two writers interleave frames, Discord drops the link, and the next
  reconnect leaks another thread — a self-feeding failure whose symptom is a bot
  that reports connected and silently stops receiving messages. Each heartbeat
  now belongs to exactly one connection, and the loop joins it before
  reconnecting.
• Telegram status tells the truth about who is slow. The activity feed sits
  above and the status line below it, and once the wait for the provider passes
  20 s the line says so explicitly instead of implying Zeline is busy. A slow
  greeting that ran no tools is no longer labelled "Working".
• Provider errors say what the status actually means. 403 is provider quota
  exhausted, not a bad API key; 402 is payment required; 404 is an unknown
  model; 429 is rate limiting. One status table is shared by the agent, the
  CLI, Telegram, media analysis, and image generation.
• /stop sends one message, and lanjut / terusin / gas resume the most
  recent thread rather than an older topic that happened to share more keywords.
• CI blocks on correctness lint. ruff check selects undefined names, broken
  f-strings, invalid syntax, and mistaken comparisons — bugs, not taste — so the
  gate can be blocking without a mass reformat. Remaining style debt is reported
  without failing the build and promoted into the gate as it is cleared.

For contributors

The repository now documents its own process: CONTRIBUTING.md,
CODE_OF_CONDUCT.md, CHANGELOG.md, issue and pull request templates, and
docs/extending.md — a written path for adding your own tools, plugin hooks,
OpenAPI tools, and MCP servers, which previously existed only as docstrings in
zeline/custom_tools.py and zeline/plugins.py.

Security

Custom tools, plugin hooks, and MCP stdio servers are arbitrary local Python in
the agent's process and load only on the workspace/full profiles — a public
gateway on safe never reaches them. The app gateway binds 127.0.0.1 by
default; exposing a routable interface exposes an agent that can run shell
commands, so put it behind a TLS terminator with its own auth and rotate the
gateway token if it leaks. Provider API keys never appear in any response.

Upgrade note

No configuration changes are required. Existing installs can upgrade in place
with zeline update, or /update from Telegram.

Installation

See the installation guide for install commands on every supported platform, and the changelog for the full list of changes with links to every pull request.

Assets

• POSIX installer: install.sh
• Windows installer: install.ps1
• Python wheel and source archive
• SHA256SUMS

All assets are built from merged main, checksum-verified, and published with build provenance.

Zeline v0.2.7

Zeline Release

Zeline is the open-source agentic AI framework by Zerolinear.

Highlights

• A first-party gateway for the mobile app — REST + SSE on /api/v1 — the
  Android/iOS client now talks to the same zeline.agent.Zeline the CLI and
  Telegram use, with no duplicated runtime. Token deltas stream as
  assistant.delta, tool activity arrives as its own tool.started /
  tool.output / tool.completed events so the client never parses assistant
  prose to learn what happened, and history replays those events as the same
  collapsible cards. Contract in docs/ZELINE_APP_API.md, every event field in
  docs/SSE_EVENT_SCHEMA.md, a working consumer in
  examples/zeline_app_client.py.
• Stop actually stops — cancellation is a flag checked inside the streaming
  read loop, so with streaming off there was no loop to check it and a stop
  request waited for the blocking provider call to return: 113–211 seconds
  measured. Streaming is now a per-instance property, and the app gateway forces
  it on because for its protocol streaming is a requirement rather than a
  preference. Cancel now lands in 2.7 seconds, and partial text is kept
  rather than discarded. The global agent.stream preference still governs the
  CLI exactly as before.
• A cancelled turn no longer erases the work it already did — the tool-call
  protocol requires every tool_calls entry to have a matching result, and
  Zeline used to satisfy that by amputation: drop the results, then drop the
  assistant message that asked for them. Stop after three of five calls had
  finished and those three real results went with it, along with the plan the
  model had written, so the next turn started blind and re-ran the same
  commands. Unanswered calls now get a result that says plainly the call did not
  complete — never a fabricated outcome, which the model would then reason from.
  The repair also scans the whole history instead of only the tail, so a dangling
  call in the middle (a parallel batch where one worker raised, a transcript from
  an older build, a crash between writing the call and its results) no longer
  leaves a session permanently rejected with nothing to do but wipe it.
• Oversized tool output is offloaded to disk, not thrown away — a large
  result used to be truncated into uselessness. It is now written to disk with a
  summary and a path the agent can read back in slices.
• Trimming archives what it evicts and injects a digest — context trimming
  silently deleted the oldest turns. Evicted turns are archived and a digest of
  them is injected, so the agent still knows what was decided fifty turns ago
  instead of confidently contradicting it.
• /version and /update in Telegram — a phone install can report its
  version and upgrade itself without ever opening a shell.
• Discord gateway — a bot over the official Gateway websocket and Bot API.
  Setup asks for a Bot Token; intents, heartbeat, and REST endpoints are
  transport details, not questions.
• openconnector skill — self-host OpenConnector and reach 1451 SaaS
  providers from Zeline over MCP.
• One-line install — the manual copy-paste checksum block is gone. It asked
  users to compare two hex strings by eye, which is not verification; artifacts
  are published with build provenance and the installer verifies checksums
  itself.

Security

The app gateway binds 127.0.0.1 by default. Binding a routable interface
exposes an agent that can run shell commands to your network — put it behind a
TLS terminator with its own auth, and rotate the gateway token if it leaks.
Provider API keys never appear in any response (/providers returns a
••••XXXX hint only), every endpoint except /health and /auth/login
requires a Bearer JWT, and /system deliberately carries no IP address.
Session ids name files on disk, so they are validated at the storage boundary
and the resolved path is asserted to stay inside the data directory.

Upgrade note

No configuration changes are required. discord and zeline_app now have
config defaults, so zeline gateway enable discord works instead of failing on
a name its own help text offered; both stay disabled until you enable them.

Installation

See the installation guide for install commands on every supported platform.

Assets

• POSIX installer: install.sh
• Windows installer: install.ps1
• Python wheel and source archive
• SHA256SUMS

All assets are built from merged main, checksum-verified, and published with build provenance.

Zeline v0.2.6

Zeline Release

Zeline is the open-source agentic AI framework by Zerolinear.

Highlights

• Tool schemas are no longer re-sent in full on every request — the schema
  payload was attached to every tool round of every turn: 17,089 characters
  (~4.3k tokens) on a stock full profile, and 25,898 (~6.5k) once MCP servers
  are connected. The new tool_search catalogue sends a small core plus a
  one-line summary of every other tool, cutting that to 6,793 characters (60%
  less) and 7,715 (69% less) respectively. Nothing becomes unreachable — every
  tool name stays visible, a catalogued tool can be called directly without a
  lookup round trip, and once a schema is revealed it stays revealed for the life
  of the session. On by default in this release, gated by two measured
  floors — a tool count and the characters actually saved — so the public
  safe profile, where hiding would save less than the round trip costs, keeps
  sending everything. zeline toolsearch prints the numbers for your own tool
  set; zeline toolsearch off restores the old behaviour byte-for-byte.
• A real browser, driven over the Chrome DevTools Protocol — web_fetch only
  ever saw raw HTML, which is useless for JavaScript-rendered pages and anything
  behind a login. The new browser tool opens, clicks, types, reads text, and
  screenshots a real Chromium/Chrome, discovered automatically on PATH or pinned
  with tools.browser_binary. Implemented as a stdlib WebSocket CDP client — no
  Playwright, no Puppeteer, no new dependency.
• Scheduled work runs inside the gateway, not in system cron — a system crontab
  entry would need its own copy of the config, provider key, and workspace; the
  gateway process already holds all three. zeline cron adds, lists, pauses, and
  removes jobs (interval or cron expression), the scheduler ticks inside the
  running gateway, and results are delivered to the chat that owns the job.
• Sub-agents run in parallel, with roles and an optional verifier —
  delegate_task accepts several tasks at once, bounded by
  max_parallel_subagents, with depth limits that stop recursive fan-out.
• code_intel: ask a real language server about the code — diagnostics,
  definitions, references, hover, and document symbols over LSP. Servers belong to
  the operator and are only ever discovered on PATH, never downloaded; when no
  language server is installed it degrades to the project's linter instead of
  failing.
• Operator extension points — zeline plugins loads Python hooks that can
  audit, rewrite, or block any tool call before it runs (one governance point for
  native, MCP, and custom tools alike), and zeline tools custom loads plain
  Python files as custom_* tools that can never shadow a built-in.
• Undo for anything the agent wrote — every write and edit is snapshotted
  first, and zeline undo lists and restores them.
• ask_user: human-in-the-loop questions mid-turn — the agent can ask a real
  question and wait, instead of guessing and being wrong expensively.
• Token accounting — zeline stats reports per-model usage and cost from
  recorded requests rather than estimates.
• Sessions are portable — zeline session export | import | fork moves a
  conversation between machines or branches one to try a different approach.
• Project rules are read automatically — ZELINE.md or AGENTS.md in the
  workspace is loaded into the system prompt once per session, so it stays stable
  for prompt caching; zeline init scaffolds one.
• Formatter runs after write and edit — the project's own formatter, detected
  from its config, so generated code matches the codebase instead of the model's
  habits.
• gateway restart and gateway update drain in-flight work — a turn already
  in progress finishes instead of being cut mid-tool-call.
• A listening HTTP adapter now reports as connected — gateway status no
  longer claims a healthy gateway is down.
• Versioned, checksum-verified installers for Termux, Linux, macOS, iSH, and
  Windows PowerShell.
• Immutable release artifacts with build provenance.

Upgrade note

tools.tool_search defaults to true from this release. Existing installs that
already have tool_search: false written into config.json keep their setting —
run zeline toolsearch on to adopt the saving, or zeline toolsearch to see the
measured numbers for your own tool set before deciding. It engages only where it
pays: profiles that would save less than 8,000 characters of schema keep sending
everything, whatever the flag says.

Installation

One line on Termux, Linux, macOS, and iSH:

curl -fsSLO --proto '=https' --tlsv1.2 https://github.com/Mftrferdinand/Zeline/releases/download/v0.2.6/install.sh && bash install.sh

Windows PowerShell:

iwr -UseBasicParsing https://github.com/Mftrferdinand/Zeline/releases/download/v0.2.6/install.ps1 -OutFile install.ps1; .\install.ps1

Then zeline setup. The installer verifies the versioned wheel against SHA256SUMS itself before installing — refusing a mismatch, a malformed digest, or a non-HTTPS URL — so there is nothing to check by hand. For origin as well as integrity, verify the GitHub-signed provenance first: gh attestation verify install.sh --repo Mftrferdinand/Zeline.

Per-platform prerequisites, checkout installs, updates, PATH fixes, and uninstall: installation guide.

Assets

• POSIX installer: install.sh
• Windows installer: install.ps1
• Python wheel and source archive
• SHA256SUMS

All assets are built from merged main, checksum-verified, and published with build provenance.

Zeline v0.2.5

Zeline Release

Zeline is the open-source agentic AI framework by Zerolinear.

Highlights

• Canonical high-agency identity shipped to every install — SOUL.md is packaged in the wheel and source archive, loaded into every agent's system prompt, and startup fails clearly if it is missing or empty. The public doctrine is now execution-first: persist through recoverable failures, keep long work visibly progressing, honor stop/cancel absolutely, and verify real outcomes—without private personas, operator PII, infrastructure, or safeguard-bypass clauses.
• Long-running commands no longer fail at 60 seconds — run_shell and execute_code accept a timeout (default 60s, up to 900s), so real pip/npm/apt installs, builds, and test suites finish instead of being reported as failures.
• Background processes with real lifecycle control — run_shell(background=true) starts servers, watchers, and long builds detached and returns a job id; the new process_control tool lists, polls incrementally, tails logs, and kills the whole process group. Finished jobs stay readable for 30 minutes.
• Forceful /stop that preserves the session — foreground shell/code processes are tracked per identity and terminated with their children; OpenAI and Anthropic streams observe cancellation per chunk; incomplete tool-call tails are repaired so the next message remains valid. Long Telegram turns display elapsed time, step count, remaining budget, and a /stop hint instead of going silent.
• Termux gateways survive Android power management — gateway polling automatically requests the app-wide Termux CPU wake lock, managed gateway start is recommended for daily Android use, and stopping an unmanaged foreground gateway never signals a shared shell process group. This prevents Zeline shutdown from taking unrelated Termux agents with it.
• Shell access remains owner-only — background shell and process_control are exposed only to the full profile, so public gateways still cannot reach a shell.
• Sanitized public skill package — removes personal account examples, payment identifiers, infrastructure details, local router state, and session-specific deployment notes from bundled skills.
• Normalized Zenith references — fixes duplicated zeline-zenith- prefixes across the bundled compatibility corpus without renaming stable skill IDs.
• Reliable public documentation — replaces unresolved website links with the repository documentation that is available now.
• Future-proof release validation — artifact checks now derive the package version from the verified release tag instead of hardcoding a version.
• Security reporting enabled — vulnerabilities can be reported privately through GitHub Security Advisories.
• Versioned, checksum-verified installers for Termux, Linux, macOS, iSH, and Windows PowerShell.
• Immutable release artifacts with build provenance.

Installation

See the installation guide for checksum-verified commands on every supported platform.

Assets

• POSIX installer: install.sh
• Windows installer: install.ps1
• Python wheel and source archive
• SHA256SUMS

All assets are built from merged main, checksum-verified, and published with build provenance.