Skip to content

Jason 0.33.0

Choose a tag to compare

@github-actions github-actions released this 09 Nov 17:23
· 52 commits to main since this release
6201450

Jason 0.33.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.32.0

An installation is taught its role skills as it is installed, from a package of them the release publishes, so a
machine needs no git to receive its skills; jason status says what a logon registration means and gives the role
skills' deployment as fields; and two new verbs move an installation to another machine.

  • The skills are a release asset. jason-skills.zip holds skills/ at the tag, both packs, and at its root a
    source.json that names the public repository, the tag and its commit. It is listed in checksums.txt after the UI's
    package, and a release is now fourteen files. With no --source, jason skills install and jason skills update
    take the package of the release this build was published as, from this repository's releases on GitHub, and check it
    against that release's checksums.txt before anything is written, so the machine needs no git. --ref takes the
    package of another release's tag; a ref that is not a release's tag is refused before any request, naming
    --source <git url> --ref <branch> instead. --source <git url> still clones with git, --source <dir> reads a
    checkout where it stands, and --feed names "a different release feed: the https address of its manifest.json, or
    http on this machine". See
    Teach it.

  • The install scripts teach the role skills as their last act. After the PATH step and before the licence lines,
    install.sh and install.ps1 run the installed executable's jason skills install --roles-only, which takes the
    skills from the release's jason-skills.zip and writes them into Jason's data directory and nowhere else, and they
    show what it prints. The scripts never start the runtime and never register it at logon: both stay yours, and
    jason status names each. When the step fails, with no network say, Jason stays installed and the script still
    succeeds, ending with one line: "The role skills were not deployed; the lines above say why. Run
    jason skills install --roles-only once that is dealt with; jason status names it as well." A script pointed at a
    feed in a directory, with --feed or -Feed, leaves the step out and says what to run instead, because the skills
    verb reads no directory.

  • jason status says what a logon registration does at the next sign-in. The autostart row says "Registered at
    logon: the runtime starts by itself each time you sign in." or "No logon registration: the next time you sign in, the
    runtime stays off until it is started by hand.", with the same repair as before; whether the runtime runs now is the
    runtime row's to say. jason runtime autostart status opens with the same words: "No logon registration." and, on a
    machine that cannot register one, "No logon registration, and this machine has no way to register one."

  • jason status gives the role skills' deployment as fields. In the JSON, the role_skills check carries
    details: ref, source, commit (empty where the record names none) and roles_taught, how many roles the runtime
    reports it teaches, which is left out where the runtime did not answer or reported that it could not read its role
    root. With no record, or one that cannot be read, there are no details, and no other check carries any. --human
    prints the facts alone, as before. A jason doctor bundle writes a skill source other than the public repository as
    <skill-source> in details as it does in the fact, and its ref too unless that is a release tag.

  • jason export and jason import move an installation to another machine. They are the CLI's tenth and eleventh
    declared exceptions: each changes this installation's files rather than asking the runtime anything, apart from the
    stop, the start and a link per project folder, and neither reaches a network beyond the runtime's own loopback.

    • What travels. jason export [<file>] writes jason-export-<UTC stamp>.zip in the folder it runs in, or the
      file you name, and never over a file that is already there. It carries the database with its -wal and -shm
      when they are there; config/, plugins/, skills/roles/, ui/custom/ and logs/, each whole, the role skills'
      record included; the harness root's tree as it stands, every folder in it whole, a .git included; and
      export.json, which names "the Jason version, the moment, the operating system, the data directory, the harness
      root, the home directory, whether the runtime starts at logon, and every file with its size and SHA-256". Of links,
      "a link at the top of a carried place, or a harness root that is one, is followed and judged where it leads", and
      "a link inside is refused by its path". And "A name another system cannot hold, and two names apart only by the
      case of their letters, are refused by their path, before anything is written", a Windows device name, such as CON
      or NUL, among them.
    • What does not. The backups under state/backups/, run/, work/, the skills' staging folders, the shipped UI
      under ui/default/, a replaced-<stamp>/ directory an import moved aside, "and anything outside the data directory
      and the harness root": the skills deployed into agent hosts among them, which jason skills install deploys again.
    • Secrets travel whole. "The archive carries the settings file with everything in it, a token under
      Plugins:Config included: keep the archive as you keep that file."
    • --stop. Without it, both verbs refuse while the runtime runs, naming jason runtime stop. With it,
      jason export stops the runtime "and starts it again once the archive is written, and starts none that was not
      running"; jason import stops it and, as every import does, starts the runtime on what it placed.
    • --replace moves aside and deletes nothing. Among what jason import <file> refuses before anything is
      written are "an archive that cannot be read", "a name in it that escapes", "a file whose size or SHA-256 is not the
      one export.json lists" and "an archive a newer Jason wrote, naming the version to install first";
      jason import --help has the whole list. An installation already here, "a database, or a harness root with a
      marker in it", is refused without --replace, naming what it holds. With it, the data directory's parts go into
      <data>/replaced-<stamp>/ and the harness root to <root>.replaced-<stamp>, each named as yours to remove.
      Without the flag nothing is written over either: "on a machine with no installation the same parts that stand
      there, a jason.db-wal or jason.db-shm beside no database among them, and a harness root folder with no marker go
      aside the same way, with no --replace; each is named as yours to remove."
    • The harness root here is "--root, else JASON_Harness__Root, else the Harness:Root this machine's settings
      file names, else Jason in the home directory". "The root is held to the runtime's rule for a root before anything
      is placed, and the placed settings file names it."
    • Paths are made this machine's. In the settings file, "every absolute path under the other machine's home
      directory, data directory or harness root is rewritten to the same path here, each rewrite said, Harness:Root
      first; a path outside those three that is not on this machine is said and left as written". Then the runtime
      starts, and the import asks it to project.link each project folder by its marker, with this machine's path; a
      refused link is said, the folder stays, and the answer's next carries
      jason project link <id> --path <folder>. "A project folder outside the harness root does not travel: each project
      whose recorded folder is not here is said, and listed as folders_not_here."
    • The logon registration travels as a fact. The import "registers at logon when the other machine did, or says
      this machine cannot". The registration itself is never a file in the archive.
    • Left to you, in this order: jason skills install, for this machine's agent hosts;
      jason runtime autostart enable, if the runtime should start at logon here and the import did not register it;
      jason status.

    See
    Moving the installation to another machine.
    operating-the-installation teaches the same move.

Fixed since 0.32.0

  • A plugin that cuts text inside a character keeps its outcome. A plugin may cut a provider's text at a count of
    UTF-16 units, as slice(0, 200) does, and leave half of a surrogate pair at the end; the plugin host could not read
    what the plugin handed it, and the work item ended plugin_no_outcome instead of the failure or the result the plugin
    declared. The host now writes such a lone half as U+FFFD, the replacement character, in any string a plugin hands
    it: a result, an identifier, a failure's message, details or block, a log line's data, a host function's options, a
    key. A whole pair is written as it is. No package changed. See
    the plugins page.
  • jason update apply names the packages that are not installed on one line. Two or more are said on the line
    where the first of them stands, as jason status says them, such as
    plugins: slack and telegram are not installed, so none was placed; `jason plugin install <id>` installs one; one
    package keeps a line of its own.
  • A release candidate's build reads its own release. A build such as 1.0.0-rc.1 takes its skills from its own
    tag, which its release publishes, and jason status compares its default UI with it, so a stale one is called stale.
    Only a development build points at the release it is on the way to.

Upgrading from 0.32.0

Nothing stops: no setting is renamed, and no start refuses a setting 0.32.0 took.

  • The executable: jason update apply, or run the install line again. Installed with Homebrew, it is the three
    lines jason update apply prints instead: jason runtime stop, brew upgrade jason, jason runtime start. The
    install line now ends by deploying the role skills; after it or Homebrew, jason skills update and
    jason ui install follow, and jason plugin install <id> --replace for each package you installed and did not edit.
  • Where the skills come from: the default skills download goes to this repository's releases on GitHub directly,
    as git did before, and not through the address ReplyApp Inc. operates for the runtime's own downloads, so
    what the responsible-use page says of it
    holds word for word and the page is unchanged.
  • No git any more: an installation whose record names this repository's git address, which every default
    deployment before 0.33.0 names, is read as the default: from the next jason update apply on, or the next
    jason skills update, it takes jason-skills.zip and its record names the new default. A deployment made at a tag
    chosen with --ref stays at its ref, a record of any other source keeps it, and a git repository named with
    --source still needs git.
  • The packages: reply 0.14.6, journal-forwarder 1.2.0, ntfy 1.0.3, slack 1.0.0 and telegram 1.0.0, as in 0.32.0;
    no package changed in this release. A release is fourteen files, jason-skills.zip the new one.
  • Skills: the update redeploys them wherever a deployment was recorded. Two skills changed their text and keep
    draft: operating-the-installation, which now says what the install script deploys and how to move an
    installation, and which no agent host has read against 0.33.0; and the responder role, whose reason for acting or
    parking at once now reads "A provider may not detect a contact's later reply unless it answers a message this side
    sent". The skills marked draft are operating-the-installation, researcher-in-session, roles/responder,
    troubleshooting-jason and the nine skills of the business pack.
  • The data directory: this release adds no database migration: your projects, campaigns, work items and chronicle
    stay as they were.
  • Going back: what jason update apply --version to an older release does to a newer plugin package, and how to
    load one again, is in
    Applying an older release.
  • From 0.31.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, then jason update apply; from a build
    older than 0.18.0, the first of the two can stop at started, as the known issue about that update below says.

Known issues

An import on the same machine, into a second data directory, "needs the source harness root moved aside first: the
records name its folders, and project.link refuses a folder present elsewhere (harness_folder_present)". The import
names each refused link, and its next carries jason project link <id> --path <folder> for each.

jason status calls autostart ok from the registration alone: a registration whose executable is not there any more
reads as registered. jason runtime autostart status reads the executable it names, and says "The executable it runs
is not there any more" with its path.

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.33.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.33.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.33.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.33.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.33.0, which jason plugin install telegram places in ~/.jason/plugins/telegram
jason-ui.zip the browser UI's package: ui/ built at v0.33.0, which jason ui install places as the default UI
jason-skills.zip the skills' package: skills/ at v0.33.0 and a source.json naming the tag and its commit, which jason skills install deploys when it is given no --source

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 | sh

and on Windows, in PowerShell:

irm https://get.jasonharness.ai/releases/latest/download/install.ps1 | iex

Jason is released under the MIT licence: https://github.com/reply-team/jason-ai/blob/v0.33.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.33.0/install.sh | sh -s -- --version 0.33.0 --no-modify-path
& ([scriptblock]::Create((irm https://get.jasonharness.ai/releases/download/v0.33.0/install.ps1))) -Version 0.33.0 -NoModifyPath

Upgrading 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.txt

On 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.