Repository navigation
Jason 0.32.0
Jason 0.32.0: the runtime, the CLI and the plugin host, one self-contained executable per platform, built
at this version and released only after its tests passed.
What is new since 0.31.0
Jason's notifications reach Slack and Telegram, every notification package is published with the release and placed by
one command, and the journal forwarder can write its lines to a file in a directory you grant.
- Slack delivers Jason's notifications. The
slackplugin, 1.0.0, posts the pointer the runtime composes as plain
text to one Slack channel withchat.postMessage, and nothing else about the work. The binding names the channel, by
its id (C0123ABCDEF), which survives a rename, or by its name; the grant namesslack.com; the bot token is read
fromPlugins:Config:slack:tokenand, where that says nothing, from a grantedSLACK_BOT_TOKEN. A delivery Slack
answered withok: falsecarries Slack's own error word in thenotification_sentline'sdetail. Its
README says how to make the app and
every outcome it reports. - Telegram delivers Jason's notifications. The
telegramplugin, 1.0.0, sends the pointer as plain text to one chat
with the Bot API'ssendMessage, by a bot you make. The binding'schatis the chat's id, a number such as
-1001234567890, or the public@nameof a channel or a supergroup; the grant namesapi.telegram.org; the token is
read fromPlugins:Config:telegram:tokenand otherwise from a grantedTELEGRAM_BOT_TOKEN, and the setting wins when
both are there. The Bot API takes the token in the path of every request, so the plugin host masks it wherever it
would write it: the line it writes about the call, a log line and a failure show[redacted]in its place. A failure
carries Telegram's own description, cut at 200 characters. Its
README says how to find a chat's id. - The three notification packages are release assets.
jason-plugin-ntfy.zip,jason-plugin-slack.zipand
jason-plugin-telegram.zipare published beside the Reply plugin's and the journal forwarder's, each the files of its
directory at the tag, listed inchecksums.txtand in the manifest with its content digest.
jason plugin install <id>places each in~/.jason/plugins/<id>once it matches both, andjason statusand
jason updateread them as they read the other two:jason update applyreplaces a copy installed as an earlier
version and places none you did not install.jason statusnames the packages that are not installed in one sentence.
See
the notifications page. - ntfy reaches a server of your own by a grant, with no edit. ntfy 1.0.3's manifest says
capabilities.http.any_granted_host: true, so a server of your own is granted by name under
Plugins:Grants:ntfy:Httpand named in the binding'sserver, and the package stays the one the release published,
whichjason updatemoves on. A grant of*meansntfy.shalone. A server that did not answer is named by its
address in the line'sdetail. See
its README. - The journal forwarder writes to a file. The forwarder, 1.2.0, adds each line to a file in a directory you grant,
beside its POST or instead of it: the directory goes underPlugins:Grants:journal-forwarder:Filesand the file under
the keyfileofPlugins:Config:journal-forwarder, or in a grantedJOURNAL_FORWARDER_FILEwhere that says
nothing. What it adds is the POST's body, one JSON object per line. With both, the file goes first; a disk that
refuses the line still leaves the POST, and the handler then ends with the disk's failure, so the line is offered
again. The file is only ever added to, and it holds what the journal says, names and reasons included, so it is a
place you trust with that. Its
README
shows both entries. jason plugin listsays where a plugin may write. A plugin whose manifest asks to write a file shows the
directories it was granted, and its--humanline counts them asfiles <n>. Ajason doctorbundle carries no
grant, this one included.- The Reply plugin's page says what is detected of a contact's later replies. Reply 0.14.6 changes its README alone:
what Reply detects of later replies by email, and which of it was observed on an account, as the known issue below
says. operating-the-installationsays where a plugin may write, and isdraftagain. It says that the directories
a plugin may append lines to arePlugins:Grants:<id>:Files, each an absolute path, read at a start and at each
jason plugin reload, and what is refused asgrant_path_refused, which rejects the whole reload: the home directory
or a folder holding it, the top of a drive, a share or the file system, the data directory or the harness root, a
folder inside or holding either of those two, a relative path,~and*. It also says thatjason update check
names no package installed as a version before its package's list of published digests begins, which for the Reply
package is 0.3.2 and for every other is 1.0.0. No agent host has read that text, so its status went back from
verifiedtodraft. The skills markeddraftareoperating-the-installation,researcher-in-session,
roles/responder,troubleshooting-jasonand the nine skills of the business pack.- For a plugin author: a file to append to.
host.appendLine(path, text)adds one line to a file directly in a
directory a person granted, and is the only way a plugin writes a file. A manifest asks with
capabilities.files: { append: true }and names no place; any kind of plugin may ask, andmanifest_versionstays
1. The line is written as UTF-8 with a line feed added and is on the disk before the call returns; the file is made
when it is not there and is never truncated, renamed or deleted. A file name starts with a letter or a digit and goes
on in letters, digits,.,-and_, at most 100 of them, with no dot last, andCON,NUL,PRN,AUX,COM1
toCOM9andLPT1toLPT9are refused on every platform. The refusals end the invocation,permanent:
capability_not_grantedwith no directory granted,file_path_not_allowedfor a path outside the grant or a name the
host refuses,file_line_multiline,file_line_too_largepastPlugins:Files:LineBytes(1 MiB, the line feed
counted) andfile_limitpastPlugins:Files:MaxCalls(64 lines per invocation). Onlyfile_write_failed,
transient, is yours to catch, and a line that passed the rules counts as a call that may have acted, so a timeout
after one isambiguous. A directory is an absolute path, resolved at the load; the home directory, the top of a
drive, a folder holding the home directory, the data directory or the harness root, a folder inside either or one
holding either, and a path that leads to one of them through a link are refused asgrant_path_refused, a package
problem that rejects the whole reload. Nothing in a line is masked, and neither the host's records nor a failure name
the directory. See
host.appendLineand
thefilesgrant. - For a plugin author: what a failure's message carries. A notification plugin's failure message is now recorded on
thenotification_sentline, where people and subscribers read it, so the delivery contract asks that it be a
diagnostic, never the notification's title or message, nor a credential. The plugin host masks the value of every
variable the plugin was granted and of its configuration, a value under 8 characters excepted, in a failure's message
and details before the outcome leaves it, so the runtime records only the masked text. A test now holds this for a
secret that rides a request's path, as a bot token does: the host's own line about the call, a log line, the failure's
message and its details all show[redacted], whether the secret came from the configuration or from a granted
variable. A successful result is still not masked. See
notification.send.
Fixed since 0.31.0
- A failed delivery says why. A notification plugin that answered with a failure was recorded with its code and
class alone; the failure's message is now thenotification_sentline'sdetail, cut to at most 500 characters,
after the plugin host has masked it as the plugin-author note says. A cut that would fall inside a character written
as two UTF-16 units steps back one, so the kept text is whole. - The Reply plugin's page no longer says that answering keeps a conversation visible. That holds for a direct email;
on a sequence thread the known issue below says what is detected.
Upgrading from 0.31.0
Nothing stops: no setting is renamed, and no start refuses a setting 0.31.0 took.
- The executable:
jason update apply, or run the install line again. Installed with Homebrew, it is the three
linesjason update applyprints instead:jason runtime stop,brew upgrade jason,jason runtime start. The
install line and Homebrew place the executable alone, so after either,jason skills updateandjason ui install
follow, andjason plugin install <id> --replacefor each package you installed and did not edit. - The packages: reply 0.14.6, journal-forwarder 1.2.0, ntfy 1.0.3, slack 1.0.0 and telegram 1.0.0.
jason update applyreplaces a copy installed as an earlier version, byte for byte as published, and leaves one you
edited alone. Slack and Telegram are new:jason plugin install slackorjason plugin install telegramplaces one,
and nothing places them for you. A release is thirteen files. - ntfy: an edited copy of an earlier ntfy reads as behind 1.0.3, and
jason statusadvises--replace. First
grant the host by name underPlugins:Grants:ntfy:Http, since a grant of*meansntfy.shalone; a copy
already granted by name needs nothing here. Keep the binding'sserveras it is. Then
jason plugin install ntfy --replacedrops the edit and asks the runtime to reload, which reads the grant you wrote
and loads the package at once, so no delivery fails in between and no separatejason plugin reloadis needed; with
no runtime running, the package loads at the next start.any_granted_hostneeds Jason 0.31.0 or newer. - The journal forwarder is 1.2.0 and asks for more than 1.1.0 did: its manifest asks for
capabilities.filesand
names no place, so it writes no file until you grant a directory. A runtime older than 0.32.0 rejects the whole reload
over that word, as every package problem rejects it, so an older runtime needs the forwarder its own release
published. Its failure codeforwarder_url_missingis nowforwarder_receiver_missing, said when neither a URL nor a
file is named: a filter of your own onsubscription_failedlines that names the old code needs the new one. - Skills: the update redeploys them wherever a deployment was recorded; after the install line or
brew upgrade jason, runjason skills update. One skill changed its status line,operating-the-installation, from
verifiedtodraft. - The data directory: this release adds no database migration: your projects, campaigns, work items and chronicle
stay as they were. - From 0.30.x or earlier, the notes of each release in between apply as well. From 0.18.x or earlier, Jason's own
installation updates through 0.19.0:jason update apply --version 0.19.0, thenjason update apply; from a build
older than 0.18.0, the first of the two can stop atstarted, as the known issue about that update below says.
Known issues
On Windows, a campaign's move to another project can be refused for the instant the background import-file sweep writes
inside that folder, soon after a start; ask again and it succeeds.
reply skills install --project does not see an old reply-adapter@reply-skills plugin installed at user scope on
Claude Code, so that plugin keeps loading beside the project copy of the skills.
reply skills install --dry-run and reply skills update --dry-run describe what they would do in the past tense, as
if it had been done; nothing is changed.
The click on a notification and its Copy prompt button are Windows only. Where another program already holds jason: links,
Jason leaves that registration alone and the toast shows without a click or a button.
On Windows, jason session open starts the console host, which hands the window to Windows Terminal where that is
your default terminal; where your default terminal is the console host itself, you get a plain console window; neither
is yet measured on a machine.
The macOS form of jason session open, a script opened in Terminal, has not been watched on a Mac.
Antigravity CLI's hook route has not been run on an account. The host also reads your own global AGENTS.md and
GEMINI.md under ~/.gemini for every role.
Two installations on one account, a build of a checkout and the installed one, take the jason: link from each other at
each toast, since the registration rewrites a key that is Jason's and names another executable. Uninstall leaves a key
that names another installation alone, so nothing is lost.
On Linux, kitty, foot, gnome-terminal, xfce4-terminal, mate-terminal and wezterm are started in the form each takes;
any other terminal program is given the host after -e as separate arguments.
Under Windows PowerShell 5.1 and cmd.exe the inner quotes of --value '{"host":"codex"}' are lost, so give the value in a file:
jason preference set agent.interactive_host --value-file host.json --actor human:<your-name>.
If Claude Code's npm postinstall never replaced its placeholder executable, jason session open reports that it started the host
and the window closes at once.
Codex CLI on Windows needs its elevated sandbox set up once by an administrator before a role can run a command; until
then every command a role runs is refused, so the role cannot report, and the attempt ends as executor_exited and is retried against the same refusal; Jason does not check for the
setup when the attempt starts.
Whether jason reaches the runtime from inside Codex's sandbox has not been checked on Linux, macOS or Windows, and on
Windows it is not yet checked whether the elevated sandbox reads only the list Jason names. Codex also reads its own global
AGENTS.md and offers every role the skills in ~/.agents/skills, whatever the profile says, so those two reach every
Codex role. Holding Codex's network to loopback rests on its network proxy, an experimental feature in 0.166.0.
Whether Cursor CLI runs the allow-listed jason command without asking, in print mode, has not been seen on a signed-in
run. If it does not, a role cannot call the runtime back, so it cannot report, and the attempt ends as executor_exited and is retried against the same refusal. Cursor CLI also reads more than the
memory files Jason names, since it takes the union of every configuration layer it finds, yours included: your own allow
rules of any kind, a shell command or a write among them, stand beside Jason's. Each attempt leaves one trust marker under
~/.cursor that Jason does not remove.
Gemini CLI reads the whole folder of each level a role's memory files are in, and the client level's folder is the harness
root, so a role reads every memory file under it. A role on Gemini CLI is also refused when the host's system policy folder
holds a .toml file, since the host would then ignore the policy Jason gives it.
Gemini CLI's --session-id and --admin-policy, which Jason passes, are in the 0.66.0 source and not in its options table.
Gemini CLI also reads your own ~/.gemini/GEMINI.md, includeDirectories and skills for every role.
GitHub Copilot CLI's reads outside the work directory, which a role needs for its memory files, are documented but have not
been seen to reach there.
Whether Copilot CLI 1.0.105 accepts every flag Jason composes is not said by its changelog, so its launch is composed from the
reference and not from a run.
A role on Copilot CLI runs under your own user-level hooks, and a COPILOT_ALLOW_ALL in your environment reaches it as the
host's own allow-all, minus what the deny list names.
A proxy flag or a proxy variable is yours to set: Jason sets none of them and reserves none of them. A flag that names a
host's own server, its credentials or its certificate check is reserved where the host has one, as the Cursor CLI section
says, and a host whose arguments are an allowlist takes no flag outside it.
On a build older than 0.18.0, the update through 0.19.0 can stop at started, saying that a library failed to load.
That update is still performed by the older build, and it happens when the two builds carry different .NET patches.
Type jason update apply again: it runs 0.19.0, which finishes the update, and one more jason update apply then
takes the newest release. From 0.18.x this does not happen: 0.19.0 is built on the same .NET patch as 0.18.0.
Through Reply, a contact's later replies by email can be lost: a lost reply reaches none of conversation.list,
conversation.get and the change feed, and Jason's inbound sync says nothing of it. A direct email's replies are all
detected, any number, a reply after an answer sent from Reply's inbox included. A second reply to a sequence email is
not detected: Reply takes the first reply to each email it sent. After an answer sent from Reply's inbox on a sequence
thread, a reply is detected only when its own headers reference that answer, and a reply to the original sequence email
is dropped. No auto-reply or out-of-office is stored on a direct thread; a reply whose In-Reply-To and References
are both empty is dropped; and a reply to a send older than 40 days is not matched unless a newer send to that address
exists. A LinkedIn thread keeps later messages, so they are read. That a direct email's replies are all detected was
observed on an account; the rest, the LinkedIn statement among them, is read from how Reply is built and has not been
observed.
A send or an invitation through Reply carries no sending time in its own result: sent_at is null, because Reply's
answer to a LinkedIn send gives a local time marked as UTC and its answer to an email gives none. message.status
reports when a send went, and a message's own moment is read from its thread, where it is true UTC.
The approval preview shows a send's send_after and not the provider object beside the arguments, so a send that also
names a sending schedule goes at the schedule's first opening at or after that moment, which may be later than the
moment the approver read.
A template held for a later moment, or queued by Reply behind the account's other sends, is filled in when it goes: a
name Reply cannot fill then fails the send after a person approved it, which message.status reads as failed with
Reply's reason.
Reply converts a LinkedIn text from HTML to text after filling it in, so markup in a LinkedIn message or InMail, a
final text or a template, does not reach the person as written; what Reply makes of a < that starts a tag there is
not known yet, and the Reply package does not refuse one on LinkedIn as it does on email.
Reply does not consult its blacklist when it takes a LinkedIn direct send, and does when it makes it: a send to a
person its blacklist holds is accepted, and fails when Reply makes it, which message.status reads as failed with
Reply's reason. Jason's own do-not-contact register is checked at the claim as before; record such a stop there with
jason suppression add as well, so the send is refused before it is made.
Through Reply, schedule.list does not say which campaign runs on which schedule: campaign.get names no schedule,
so which one a campaign sends on is read at Reply.
Through Reply, a reply on a thread, conversation.reply, is not held to the rule on a < that starts a tag yet, and
its text goes as written; whether Reply cuts a reply as it cuts a direct email has not been seen, so write an address
in a reply without its angle brackets.
The responder's skill ships marked draft: no agent host has read its text in the state it ships in. Its commands parse
against this build, as every skill's do, but how an agent follows its loop on a real reply is not yet seen.
Assets
| File | For |
|---|---|
jason-win-x64.zip |
Windows on x64 |
jason-linux-x64.tar.gz |
Linux on x64 |
jason-osx-arm64.tar.gz |
macOS on Apple silicon |
manifest.json |
what a running Jason reads to learn that this release exists |
checksums.txt |
the SHA-256 of each archive and of each package, in sha256sum format |
install.sh |
macOS and Linux: the install script this release was published with |
install.ps1 |
Windows: the install script this release was published with |
jason-plugin-reply.zip |
the Reply plugin's package: the files of plugins/reply at v0.32.0, which jason plugin install reply places in ~/.jason/plugins/reply |
jason-plugin-journal-forwarder.zip |
the journal forwarder's package: the files of plugins/journal-forwarder at v0.32.0, which jason plugin install journal-forwarder places in ~/.jason/plugins/journal-forwarder |
jason-plugin-ntfy.zip |
the ntfy plugin's package: the files of plugins/ntfy at v0.32.0, which jason plugin install ntfy places in ~/.jason/plugins/ntfy |
jason-plugin-slack.zip |
the Slack plugin's package: the files of plugins/slack at v0.32.0, which jason plugin install slack places in ~/.jason/plugins/slack |
jason-plugin-telegram.zip |
the Telegram plugin's package: the files of plugins/telegram at v0.32.0, which jason plugin install telegram places in ~/.jason/plugins/telegram |
jason-ui.zip |
the browser UI's package: ui/ built at v0.32.0, which jason ui install places as the default UI |
Each archive holds the executable, LICENSE (the MIT licence, which covers the whole repository, the runtime
included) and THIRD-PARTY-NOTICES, nothing else. The Reply plugin's package is installed by
jason plugin install reply, which places it in ~/.jason/plugins/reply once it matches its line in
checksums.txt and the manifest's content digest; step 3 of docs/golden-path.md runs it. The journal forwarder's
package is installed the same way, by jason plugin install journal-forwarder, into
~/.jason/plugins/journal-forwarder; its README says how a receiver on another host takes a grant and a configuration
and no edit of the package. The packages of ntfy, Slack and Telegram are installed the same way, each by
jason plugin install <id>, into ~/.jason/plugins/<id>; each one's README says what it takes to name it as a
notification channel. The UI's package is placed by jason ui install, which the install guide runs and
jason update apply runs at its end.
On Linux the executable needs the ICU library (libicu), which desktop distributions carry and minimal
images may not; the install script stops, with the runtime's own message, rather than install a program that does
not start.
Installing
One line, on macOS and Linux:
curl -fsSL https://get.jasonharness.ai/releases/latest/download/install.sh | shand on Windows, in PowerShell:
irm https://get.jasonharness.ai/releases/latest/download/install.ps1 | iexJason is released under the MIT licence: https://github.com/reply-team/jason-ai/blob/v0.32.0/LICENSE.
Both find this machine's archive, check it against checksums.txt before unpacking, and put jason on the
PATH — in ~/.local/bin, or %LOCALAPPDATA%\Programs\jason — with its licence and the third-party notices
beside it, as jason-LICENSE and jason-THIRD-PARTY-NOTICES. Running the line again over an installed Jason of
the same version changes nothing and says so, unless a licence file is missing beside the executable, which it
then writes. Two options, for a script that must be told:
curl -fsSL https://get.jasonharness.ai/releases/download/v0.32.0/install.sh | sh -s -- --version 0.32.0 --no-modify-path& ([scriptblock]::Create((irm https://get.jasonharness.ai/releases/download/v0.32.0/install.ps1))) -Version 0.32.0 -NoModifyPathUpgrading from 0.1.0
If this machine ran 0.1.0 with autostart enabled, run jason runtime autostart enable or disable once from an
ordinary prompt — if that answers Access is denied, follow its message first — then jason runtime stop once, then
jason runtime start (or sign in again, with autostart enabled). 0.1.0's logon task started a runtime that outlives a
sign-out and holds the data directory; until it stops, the runtime this version starts at sign-in finds the directory
taken and exits.
Checking a download by hand
sha256sum --check --ignore-missing checksums.txtOn Windows, compare Get-FileHash of the archive with its line in checksums.txt.
If you then put the executable in place by hand, keep LICENSE and THIRD-PARTY-NOTICES beside it, named
jason-LICENSE and jason-THIRD-PARTY-NOTICES.
What is signed
The macOS executable is signed with Reply's Developer ID and notarized by Apple. Before anything is published, the
release's macOS job has spctl assess the executable's signature and stops unless that signature is accepted from the
source Notarized Developer ID; the same job starts a copy carrying the quarantine flag a browser puts on a download,
and its log says whether that copy started and opened its database. The ticket is not stapled to the file, which a
bare executable has no place for; for a file without a stapled ticket, Apple's documentation says Gatekeeper finds the
ticket online. The quarantine flag is put there by the browser that downloaded the file, not by curl, so the
one-liner's download has none and install.sh clears nothing; an archive fetched with a browser and unpacked by hand
keeps the flag.
Who signed it is yours to read: codesign -dv --verbose=2 on the unpacked executable prints an
Authority=Developer ID Application: line naming Reply and its team id in parentheses, the same id the
TeamIdentifier= line gives. spctl accepts the signature of any notarized Developer ID from the source
Notarized Developer ID, so it is that name and that team id, not the acceptance, that say the executable is Reply's.
The one native library the executable carries, libe_sqlite3.dylib, is signed with the same Developer ID and
timestamped before it is bundled; the executable unpacks it under ~/.net/jason/ the first time it runs, and
codesign -dv --verbose=2 on it prints the same Authority= and TeamIdentifier= lines. So the executable keeps the
hardened runtime's library validation, which loads only a library signed by Apple or by the executable's own team, and
it ignores DYLD_ environment variables: the only entitlements it carries, com.apple.security.cs.allow-jit and
com.apple.security.cs.allow-unsigned-executable-memory, let the .NET runtime compile code as it runs.
The Windows executable is signed with Reply's certificate through Azure Artifact Signing, and timestamped under
RFC 3161, so the signature stays valid after the certificate expires. Who signed it is yours to read, in Windows
PowerShell or PowerShell alike: Get-AuthenticodeSignature on the unpacked executable says Valid, and, run where it
was unpacked, (Get-AuthenticodeSignature .\jason.exe).SignerCertificate.Subject prints the subject the certificate
is issued to, which begins CN=ReplyApp Inc.; signtool verify /pa /v, where the Windows SDK is installed, accepts it
and prints the timestamp. An archive a browser downloaded carries the mark of the web, and
SmartScreen looks at the executable unpacked from it the first time it runs. SmartScreen's reputation for a new
publisher builds over downloads, so in the first weeks of signed releases a download may still show its dialog;
install.ps1 clears that mark from what it unpacks.
The Linux executable is not signed, and nothing else a release carries is either.
Both scripts check the archive against checksums.txt before unpacking. On Linux that check is the only provenance
there is; on macOS and Windows the signature says who built the executable as well.