Repository navigation
Jason 0.42.0
Jason 0.42.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.41.0
This release is about two things: how much of the sending you keep in your own hands, and your own AI changing Jason
itself. You say, for people who have not answered and for people who have, whether each message waits for your yes or
goes on its own. Where it goes on its own, a critic reads it first, and a doubt, a text nobody passed, a reply not yet
judged, a message written in the desktop's chat and the day's limit still bring it to you. Jason now knows which of the
two kinds a person is, and waits for a reply to be judged before it writes on its own to someone who just wrote; and a
person who asks not to be written to is never written to again, on any address. And your own AI can now change Jason
itself: its roles, its plugins, a route for every campaign and what a plugin is granted, from the command line or from
Open in, with a skill and a page that say how.
- Say how sends go, for people who have not answered and for people who have. Two named preferences,
send_mode.coldand
send_mode.warm, eachautomaticorevery_message, set by a
named person withjason preference setand read when a send is claimed. A campaign may hold a mode of its own with
jason campaign set-send-mode <campaign-id> --cold … --warm …, set under a person's name and given back to the
installation's preference with--clear; naming neither mode, and an archived campaign, are refused.jason status
says which mode is in force for each kind of contact and where it comes from, andjason campaign get --humansays
the campaign's own. A mode nobody has set reads asevery_message, so installing this release changes nothing about
how your sends go, and every approval names the preferences still unset. No role sets a mode, and a request from
inside a run is refused. - Under
automatic, a message goes without asking you, and some still come to you. Where the mode for a contact's
kind isautomaticand a named person set it, the claim releases a message, a reply or an invitation under an
approval born approved, with the reasonautomatic_mode, decided in the name of the person who set the mode, and
writes anapproval_automatic_appliedline. It goes only once the runtime's critic, or a person by name, has passed
the text as it now reads. It waits for you instead, under an approval whose reason says why in one sentence, where it
was written or edited in the desktop's chat; where its creator or a reviewer doubted it; where the contact has a reply
not judged yet, or one judged before Jason recorded what kind of reply it was; where it answers no judged reply, or an
automatic reply, a bounce or a request to stop, or a conversation a role marked for you; where nobody passed its text,
or it was edited after the pass; and once the campaign has reached the day's ceiling. A standing approval still lets
a reply go where it waits only for its contact's reply, for what it answers or for a review, as before; it never lets
go one written in the chat, a doubted one or one past the ceiling. A retry reads the contact again, so a reply that
landed in the meantime brings the message back to you. See
the send mode at the claim. - The critic reads each automatic message first. When a send to a person is created while the mode for its
contact's kind isautomatic, the runtime creates acriticwork item for it in the same save, naming the send in
the reserved context keysend_review, and the send waits on it. Only that critic's pass, or a person's, lets the send
go: a critic somebody queued by hand, or the critic of another send, is shown to you and releases nothing. Nothing is
created underevery_message, for a send that carries its creator's doubt, for one written in the desktop's chat, or
where no critic could be launched; a critic that fails or ends without a review leaves the send to you, unless a
standing approval covers it. The critic's skill knows that under an automatic mode its pass is the last look. - A daily ceiling of automatic sends.
Sending:AutomaticMaxPerDay, 100 unless you set it, from 1 to 1000, is the
most sends the automatic mode releases from one campaign in a UTC day, counted since 00:00Z by the releases it wrote,
whatever became of each. At the ceiling the next send waits for you with the reasondaily_ceiling, and its preview
says the limit, the count and since when; a standing approval does not let it go either, and a new day does not
release it on its own. There is no 0 and no unlimited: to send nothing automatically, set the mode to
every_message. - The desktop's chat is never a person's word. Every request the chat's CLI sends carries the header
Jason-Confined, and the runtime records it on the work, the edits, the verdicts, the reviews and the standing
approvals made under it: a send written there always waits for you, a verdict there lifts no opt-out, a review there
is no person's pass, and a standing approval set there sets nothing. The chat refuses a campaign's send mode and the
send-mode preferences in every access mode and on every platform, refusesworkitem.review, refuses a denied verb in
any letter case, and can neither claim to be a run nor inherit being one. - Send modes in the console. An approval card asks "How should messages go?" while a mode is unset, for people who
have not replied yet and for people who have: Every message waits for you or Goes automatically, with
Remember this. Settings sets the choice for every agent, an agent's own Settings tab sets its own, and System says
which mode is in force and where it comes from. A doubted message shows on its card who doubted it and why, in their
own words, and a held message says why it waits; one that went without asking you says so on its card, with the mode
it went under. - Jason knows whether a person has answered.
jason reply recordtakes--nature:person,automatic,bounce
oropt_out, in the runtime's own words. A contact is cold until a verdict that stands judges a reply of theirs, in
that campaign, a person's answer; from then on they are warm. A reply nobody has judged yet makes the contact wait,
even a warm one, since a new reply may be a request to stop; and where Jason cannot prove a reply judged, because a
thread runs past one page or a read did not finish, the contact keeps waiting rather than being taken for warm or
cold. See cold, warm or waiting and
the Runtime API. - A person who asks not to be written to is stopped on every address. A verdict whose nature is
opt_outputs every
address and profile the contact has on the do-not-contact register in the same act, by the runtime's own actor, and
the claim refuses work about that contact in every campaign, including for a value they gain later. Only a person's
own later verdict, under their name and outside any run and the desktop's chat, lifts it; a role's verdict, or a
person named from inside a run, never does. A claim that refuses for this saysopted_out. See
the claim's checks. - A doubt about a message reaches you before anything can release it. The one composing a message can say at
creation, with--ask-personand a code, that you should look at it, and a role that reviews a message can pass it or
doubt it withjason workitem review, bound to the text it read; an edit voids the review. A send can be created
waiting on its review with--wait-on. A doubt goes ahead of a standing approval and of the automatic mode, so
neither lets a doubted message go without you. Nobody reviews a message they wrote or edited, and a message edited
under no name is reviewed only by a person by name. See
doubts about a send. - The quick-start skill reads your accounts before you say go. It tells you how many mailboxes and LinkedIn
accounts are connected through the provider your sends go through, in the same message as the plan, and a read that
fails or is slow never holds the question up. - Change Jason itself. A new entry in the desktop's Open in menu, below Copy path, opens your own AI in a new
terminal at Jason's role skills folder, with the plugins folder beside it where the AI takes a second folder (Claude
Code and Codex), and a short first message that sets the session up for changing Jason. The AI is the one your
preferenceagent.interactive_hostnames, else Claude Code, else Codex. It is offered in your own installation only,
never in the demo. The desktop's chat still cannot change Jason's roles, plugins or settings, on purpose: asked to, it
now says so and points you to this entry. See
Changing Jason. jason session open --setup. The same session from a terminal:jason session open --setup [--host <word>]opens
your agent host at the role skills folder, adds the plugins folder for Claude Code and Codex, and sends the setup
brief as its first input. Every folder comes from whatjason statusreports, not from a remembered path. It starts
no runtime and writes nothing of Jason's. Where thecustomising-jasonskill is not yet deployed for that host, the
answer says so, and the brief asks the AI to install it on your yes before it changes anything.--setupcannot be
combined with an approval, a question, a campaign, a project,--here,--shellor--resume.- A skill and a page for changing Jason. The runtime pack gains
customising-jason, and the documentation gains
Changing Jason. Both tell your AI, or
you, where the parts are, read fromjason status. They say what a role's skill changes: that role, in every
campaign. A standing rule for one campaign, one project or all your work goes in the memory file at that level
instead; a fact every role of one campaign shares goes in the campaign's context; how you sound goes in the tone of
voice preference. So the AI asks which you mean before it edits a role. They also say how a new role, a plugin, its
grants, a secret and a global route are added and when each takes effect, what an update keeps, and what is never
touched. - A route for every campaign from the command line.
jason route set --global [--operation <op> [--channel <channel>]] --plugin <id> --actor human:<you>andjason route unset --global [--operation <op> [--channel <channel>]] --actor human:<you>write the global route, the default for every campaign
with no route of its own or one operation's, or one channel of it, intosettings.jsonand put it in force in the
same act, where before it was a hand edit followed byjason plugin reload. Every byte of the file the route does not
own is kept: comments, layout, line ends, the other sections and every plugin secret. A reload that refuses the new
route puts the file back, and the answer says whether it did. A route is never written while another program changes
the file, or where aJASON_environment variable overrides it (setting_shadowed, naming the variable). It is never
written from inside a run either: nothing inside a run changes Jason itself. A write now needs exactly one of
--campaignand--global. See routing. - A plugin's grants from the command line.
jason plugin grant <id>andjason plugin revoke <id>name one entry
of one capability, with exactly one of--http,--exec,--env,--api,--filesand--subscription. The grant
is written underPlugins:Grants:<id>through the same writer and put in force in the same act. The verb is stricter
than the file: it refuses what the plugin's manifest does not ask for (grant_unrequested), except a host where the
manifest saysany_granted_host. It refuses a directory the loader would refuse, and revoking one entry that a*
grant covers (grant_held_by_star). Both verbs need--actor, and are refused underJASON_CONFINED, by the
desktop's chat in every access mode, and inside a run. Where a plugin is granted nothing it asks for,jason plugin install --human,plugin list --human,plugin reload --humanandjason statusnow name the command that grants
it. See plugins. - Where Jason keeps its parts, in
jason statusandsystem.info. Both gain asetupsection, the last one: the
role skills folder, the plugins folder, the custom UI folder, the settings file, whether the settings file is also
where plugin secrets are kept, and the data directory's layout.jason status --humanprints them under the checks:Role skills:Plugins:Custom UI:Settings:, with "(where plugin secrets are kept)"Layout:
statuscomposes the section itself, so it is there when the runtime is not running.jason doctorcarries both
records, with their paths rewritten as it rewrites every path.
- The data directory's layout stamp. A data directory may now carry
layout.json, which says how it is laid out:
{"layout": N, "written_by": "<version>", "at": "<moment>"}. This release writes none and moves nothing. It reads the
stamp so that a later release can move the parts you edit, and a Jason that does not know that layout refuses to touch
the directory rather than recreate an empty plugins folder beside the moved one or lose a secret. The desktop reads
the stamp by the same rules, and places the settings file, the plugins and the role skills by it.
Fixed since 0.41.0
jason importsays when a project folder was not linked. It exited 0 even when the runtime refused to link a
project's folder. It now exits 1, with everything placed and the whole answer printed, names each refused link in
link_refusedwith its project, folder, code and message, and keeps thejason project linkline innext.- The install prompt's first line no longer ends in a full stop; a copy that still has one works as before wherever
the agent reads the address as an address. - A settings file with an undecodable
\uescape no longer escapes the parser. The runtime used to throw on such a
file, both when it was edited live and on a reload. It now treats the file like any other that does not parse: it
keeps running with the last good settings, and the reload answerssettings_file_unreadablewith the line and byte
where the parser stopped. - The
plugin_packagecheck ofjason statusnames the right folder. It used to build the folder from the
runtime's data directory. It now names the folder that the command it suggests,jason plugin install, places a
package in.
Upgrading from 0.41.0
Nothing stops and no setting is renamed. Four database migrations run on the first start, after the backup the runtime
already takes: an index for reading a thread's verdicts, the campaign's own send modes, room for a send's doubt notes,
and an index for counting a campaign's automatic sends of the day.
- The executable:
jason update apply, or run the install line again. After it,jason skills updateand
jason ui installfollow: the first brings this release's skills, the critic's among them, and the second the
console's send modes. - The packages: reply 0.15.1, journal-forwarder 1.3.0, ntfy 1.0.3, slack 1.0.0 and telegram 1.0.0, each the same as
in 0.41.0, so there is nothing to replace withjason plugin install. - Your sends go as before. Neither send mode is set by an update, so every send to a person still waits for a person
until you set one;jason statussays so. - The desktop's chat: a send written in the desktop's chat always waits for the person, even where a standing
approval would have covered it. - What automatic costs. Where a send mode is automatic, each message to a contact of that kind costs one more AI run,
the critic's, and the critics share the campaign's one slot with its other role work. - An opt-out before this release is held as before, by the register entries made for it then. The new opt-out lock
reads only verdicts that state the natureopt_out, which no verdict recorded before this release carries, so an
address such a contact gains after the update is refused only once it is put on the register by hand. - A contact whose last reply was judged before this release waits for its nature, since such a verdict states none,
until a verdict that does is recorded on that thread. - The desktop is a separate install, as before:
jason updatedoes not install it. Download the installer or the
disk image for your machine from this release, or let an installed desktop offer the update. - Update the desktop and Jason together. This release's desktop carries the chat's refusals of the send modes, and
its console the send modes' card and settings; and Change Jason itself runs this release'sjason session open --setup, which an earlierjasonrefuses as a usage error. - The skills: after
jason update apply,jason skills updatedeploys the newcustomising-jasonskill to every
host the skills were deployed to. Until it runs,jason session open --setupsays that the skill is not deployed, and
the setup brief asks your AI to install it on your yes. - No layout stamp means layout 1, and nothing moves. Every installation so far has no
layout.json, and every path
is the one it was.jason statusgains one required check,layout, which passes on such a directory, and its
setupthe memberlayout.export.jsongainslayout, and an archive without it, as every earlier Jason wrote,
imports as before. - A newer layout is refused, not followed. Where
layout.jsonnames a layout newer than thisjasonruns, or
cannot be read, the runtime's start and these verbs refuse before anything is read or written, aslayout_neweror
layout_unreadable, exit 1:jason runtime startandrestart,plugin installandreload,skills installand
update,ui install,update applyandrollback,export,import,uninstall --purge-dataandsession open --setup.update applyandrollbacksay to install that newer Jason by running the install line again.jason status,jason doctorandjason logsnever refuse on a stamp, since they are how such an installation is looked
at.uninstall --purge-datakeeps asetupfolder that no stamp says Jason made. - The runtime now writes its own settings file, in exactly two places: a global route and a plugin's grants. A hand
edit is still read as before. A grant written by hand for something the manifest does not ask for still only warns. - A global route or a grant is refused inside a run as
decided_inside_a_run, with a sentence of its own: nothing
inside a run changes Jason itself. The sentence for an approval or an answer inside a run is unchanged. - Refusals that found nothing routed used to say "write a global route in the settings file".
route.resolve,
operation.describeand the audience reads now namejason route set --globalinstead, and so doesjason status. jason doctor --include-journalnow also carries the two new journal lines,global_routes_updatedand
plugin_grants_updated: the account a global route binds, and a plugin's granted hosts, programs, variable names, API
families, directories and journal kinds before and after, never a value. Neither line can be subscribed to for now.- From 0.40.x or earlier, the notes of each release in between apply as well.
Known issues
The opt-out lock holds by the contact's record: another contact record of the same person, with a value the opted-out
record never had, is not covered, since Jason does not merge contacts. The register still holds every value the
opted-out record had.
Where a provider does not say which person a reply is from, Jason cannot hold an automatic message to that person until
the reply is judged: until a verdict names them, a first message to them may still go.
A reply this campaign heard of only because another campaign knows the same person neither makes that person warm here
nor holds a message to them here.
Under automatic for people who have replied, a message that is not an answer, such as a follow-up planned before the
person wrote, can still go to them on its own after their reply was marked for you. Only an answer in that conversation
is held.
route set --global and plugin grant refuse a settings file that is a link to another file
(settings_file_not_editable), since a write would replace the link with a file of its own. Edit such a file by hand
and run jason plugin reload, as before.
The runtime writes the settings file only if it still holds what was read, and makes its edit again from a fresh read
when another program changed it in between. A program that writes the file in the instant between that check and the
rename can still lose its change. Editing settings.json by hand while a route set --global or plugin grant runs is
the case to avoid.
jason session open --setup adds the plugins folder only for Claude Code and Codex. Another host opens at the role
skills folder alone, and reaches the plugins folder by the path jason status prints.
The demo has limits: it is email only, with no LinkedIn channel; it raises no question; a person whose message waits for your approval never answers it, because a reply is attributed once, when it is stored; and no AI role runs in the demo's runtime, so no reply there is judged, and Interested, Meetings booked and Replies by category have nothing to count. The sample's story began when the release was built, with no past before it, so the Dashboard's 30 days hold it for thirty days after. Where the sample is placed, the replies the story wrote are already in when the demo opens; where it is made at the start instead, its story starts that day and its replies arrive within minutes. After that, a kept demo shows nothing new of the story until Start the Demo Over. In a placed demo the Dashboard's daily trends read ±0 at first, since nothing of the story falls in the last 24 hours.
Open in's Browser hands the link to your browser as an argument. If the browser was not already running, its main
process keeps the link, with the pairing code in it, in its arguments for its whole life, where another program of your
account can read it. The code is spent on its first use or expires within sixty seconds, whichever comes first, and a
spent or expired code opens nothing.
Through Reply, a person the account already holds is never found by audience.search, however well they match, while
audience.preview counts and samples them, so a search can find fewer people than its preview said. A person the
campaign holds and Reply does not, one brought from a file say, can be found by a search again and is charged for; Jason
keeps them the one member they are.
A person the campaign holds from elsewhere, found by a search under another address, with no LinkedIn profile the two
share and no identifier of that provider pinned, becomes a second contact: a name never matches anybody.
Through Reply, a stop deletes the search's list: the people Reply found since the last read are charged, stay Reply's
contacts and never land in the campaign.
A search a person resumes at the provider after it ended stalled is not followed by the poll again; a read anybody
makes still lands its page: jason workitem create <campaign-id> --kind provider_op --operation audience.search_status --input '{"search":"<the search's work item>","limit":100}'.
The guard that keeps a route for a deferred send has two limits. A send with no moment known is not guarded, though its result says it can be cancelled: a provider answers a send it will make as soon as it can the same way as one it keeps queued for a sending schedule of its own. And a send still on its way when its route changes is not guarded: it can succeed under a plugin and account no route names any more, and it is logged only at the next start. If the route of such a send has moved, cancel it at the provider.
A thread is matched to its plugin, not to its account: a reply routed to another account of the plugin that holds the thread is not refused by Jason, and the provider refuses it as a thread it does not hold.
A threshold set while nobody is on the campaign says at once that the reserve is low, since a count of nobody is under
any threshold, and wakes the manager for nothing. Set it once a search's people have landed.
The audience reserve counts a campaign's archived members nobody started work for, while the page's count of new
people leaves them out, so the reserve can read higher than the page and the notice that the reserve is low can come
later than the page suggests.
Routes changed while the runtime was stopped, the settings file edited by hand say, are not refused at the next start,
which has no routes in force to keep, and a search whose start is under way when a route changes is not counted yet. A
deferred send stranded that way is logged once at the start, by its work item, campaign and plugin, and every later change
that would strand one is refused. A
search still followed whose account the routes then name nowhere is said in the log at warning, with its campaign; until
a route names that account again, its reads and its stop are refused and it goes on at the provider to its count.
A search the provider had already ended when its campaign was archived ends as it ended, and through Reply its list
stays at Reply with any people not yet read. A search whose start was under way when its campaign was archived has no
record yet, so nothing stops it: whether Reply took the start is read at Reply.
In Ask first, and in Plan only, the desktop's chat runs jason audience preview, jason audience filter-values and
jason audience availability without a card, as in 0.36.0. Each one asks the provider, and nothing in Jason limits how
often a chat, or any client holding the run token, makes them, or how many run at once: each starts a plugin process of
its own, so a typeahead asking a filter's values at every key starts one per key.
Codex in the desktop's chat reads and advises, and asks for nothing: it runs in Codex's read-only sandbox.
In a Codex chat a command can read what you can, a plugin's secret written in settings.json included; chat on Claude Code where that matters.
The Windows check of Codex's sandbox has been proven against a stand-in only where the elevated setup is missing. On the one real machine checked before this release, a command inside the elevated sandbox was refused Jason's run file and could still read Jason's settings file; the check now rests on the run file, and has not been run on a real machine since. Whether naming the elevated sandbox raises an administrator prompt where it is not set up has not been seen.
On a Mac and on Linux, a read-only Codex turn can read the runtime's run file, so if the loopback interface is reachable from it, a command in a Codex chat could reach Jason's runtime. Codex's read-only mode has no network by the vendor's own description; that has not been probed.
A Feed row for a send says the provider took it: a send it accepted for a later moment, or for its own queue, appears
at once and can still be cancelled until it goes.
The Feed folds a line only into the one just before it, of the same kind, campaign, operation and role, so sends that
alternate with other lines, an approval and its send say, or two campaigns sending at once, are shown one by one and
fill the Feed's 500 lines and the fifty a Feed turn is given sooner.
When the window loads, the desktop reads back the newest hundred finished work items of any kind since the Feed's
newest line and keeps the sends and the five roles' work among them, so on a busy installation, where a campaign's
reads finish at every cadence, fewer than a hundred of these may come back. Older ones are not shown, no gap is said
for them, and they stay in the journal (jason journal list --kind workitem_succeeded). A catch-up whose read fails,
or that finds the Feed holding no line yet, brings in no sends.
A people search with text reads the custom fields of every contact it scans, one at a time, the pickers and the console's
search box that search as you type included; on a large installation a search takes longer than a search by name alone did. No measurement has
been made.
A desktop start whose runtime does not start skips the reset of what an earlier page kept, until a start that starts the runtime.
A long-running runtime can be ended by a rare fault in the SQLite provider's connection pool (dotnet/efcore#38854); nothing recorded is lost, starting it again continues the work, and the runtime's log now says what ended it.
jason campaign audience lists an audience's latest hundred searches at most, with no page past them, so an allowance that tops an audience up for long enough leaves its older searches out of every read of the API but their work items and their lines in the journal. And two endings of the real reply-cli have only been met by a stand-in: outcome.unknown at exit code 1 from live-data start, which the Reply package reads as a lost answer, keeping the search's list for its repeat to find the search by; and live_data.service_failed after Reply did save the search, which the package reads as nothing started, so it deletes the list and the attempt is repeated. Should Reply ever answer so, a person would see a search at Reply that Jason does not follow, spending credits into a list that no longer exists, while Reply refuses the repeat, search_in_progress, and its work item fails; stop that search at Reply.
Under a Reply route whose binding names no profile, the binding is whichever profile reply-cli is set to, so switching reply-cli to another profile makes every read and stop of a search Jason follows fail search_not_found, and each such search ends cancelled while it goes on at Reply under the first account, its people never landing. A binding that searches should name its profile.
Not yet seen on a real machine:
- The Linux packages by hand on Ubuntu 24.04: the tray on GNOME and KDE, the keyring, start at login across a sign-out, a deb update's password prompt, the AppImage replacing itself, Remove What Jason Placed, and a
jason-desktop://link clicked. - The chat with real hosts and keys: a wrong key on each provider, which account pays when a plan is signed in, each effort level, Plan only and its plan card on a real Claude Code, Auto-edit on a real Claude Code, and Full access kept with Always across a restart.
- Routes by channel with two real providers: the tests run a campaign through two stand-in plugins.
- On Windows, a click on one of Jason's notifications bringing the desktop to the front on Needs you, with the desktop open and with it closed.
- The Reply card's account acts, and the Accounts page that draws the same card, on a real Reply account: connecting an account and reconnecting one, pausing a LinkedIn account and resuming it, and the link pages they open in the browser; with them the shared mailbox page, LinkedIn ids for Reconnect, and the confirmation box in a packaged build.
- On macOS, Remove What Jason Placed and the LaunchAgent; on every system, how the icon looks in the menu, the dock and the taskbar.
- Open in with real editors, terminals and file managers, and Continue this chat with a real Claude Code or Codex: the tests run against stand-ins, and the words that continue a conversation were read from each program's own help.
- The console in a tab of a real browser that the desktop opened: the page's tests run against a stand-in for the desktop's side, and the desktop's against a test client.
- The demo placed from the release's archive on a Mac and on Linux: the placing has been timed on Windows alone.
The AppImage refuses to start on a system that refuses its sandbox, with a sentence naming the deb; that refusal has not been seen either.
The Mac executable built for Intel is signed and notarized like the Apple silicon one, but the test suite does not run
on an Intel Mac, so that package is covered by what was built and signed and not by a run. Its jason moves only with
the desktop's own update, because jason update publishes no build for it.
The Windows installer ends the run, and installs nothing, when a process from the carried jason.exe still runs after
the stop; the next start of the application says nothing of it. Where PowerShell is not available the installer looks
for no process: a person is asked to stop the runtime, and an update goes on without a look.
The six libraries the Windows installer unpacks into its temporary folder (nsExec, nsis7z, SpiderBanner, StdUtils,
System and WinShell) carry no signature of ours. The installer's builder cannot sign them, and they are never installed.
The desktop's chat has been run in tests against stand-ins for Claude Code and Codex; no turn with a real host has been
watched through the desktop yet.
Work the desktop's chat queues for a role runs under that role's own execution profile, not behind the chat's cards.
The candidate 0.34.0-rc.1's desktop carries a jason without this refusal; jason update apply typed into it replaces
the file inside the application before any code of the new build runs. The new build finishes that update and refuses
the next one; the desktop's Check for Updates then brings the application to the same version. Such an update that
stopped at kept, before the new file was in place, leaves its record at ~/.jason/update/ledger.json, in the data
directory, and every start of the runtime refuses while it is there; the desktop's jason once updated refuses to
finish or roll it back, so removing that file is what lets the runtime start.
The desktop's tray has not been seen on a screen, and the View menu's keys have not been typed at the operating system's
level; the page receives them, but no run has shown the menu's accelerators fire. A person's run of the installed
candidate covers both.
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 plugin from the reply-skills marketplace
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, with an item or at
a folder, nor has the data directory it carries, nor the login shell --shell reads from Terminal's own environment.
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. The terminal process is the CLI's own
child and inherits its JASON_DATA_DIR; a terminal that hands the command to a server of its own already running may
start the agent host in that server's environment instead, and whether any does has not been determined.
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.
The quick-start skill ships marked draft as well: its words, and the install guide's hand-over to it, are held by tests,
and no agent host has yet been watched following it from a ready installation to a first campaign.
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.42.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.42.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.42.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.42.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.42.0, which jason plugin install telegram places in ~/.jason/plugins/telegram |
jason-ui.zip |
the browser UI's package: ui/ built at v0.42.0, which jason ui install places as the default UI |
jason-skills.zip |
the skills' package: skills/ at v0.42.0 and a source.json naming the tag and its commit, which jason skills install deploys when it is given no --source |
jason-desktop-windows-x64-setup.exe |
Jason Desktop for Windows on x64: the installer, signed |
jason-desktop-windows-x64-setup.exe.blockmap |
what the Windows desktop's updater reads to download only the parts of the installer that changed |
latest.yml |
the Windows desktop's update feed: this version, the installer's name and its SHA-512 |
jason-desktop-macos-arm64.dmg |
Jason Desktop for macOS on Apple silicon, to drag into Applications: signed, notarized and stapled |
jason-desktop-macos-arm64.zip |
the same application for Apple silicon, as the Mac desktop's updater downloads it |
jason-desktop-macos-arm64.zip.blockmap |
what the Mac desktop's updater reads to download only the parts of the Apple silicon zip that changed |
jason-desktop-macos-x64.dmg |
Jason Desktop for macOS on Intel, to drag into Applications: signed, notarized and stapled |
jason-desktop-macos-x64.zip |
the same application for Intel, as the Mac desktop's updater downloads it |
jason-desktop-macos-x64.zip.blockmap |
what the Mac desktop's updater reads to download only the parts of the Intel zip that changed |
latest-mac.yml |
the Mac desktop's update feed: this version, each zip's name and its SHA-512 |
jason-desktop-linux-x64.deb |
Jason Desktop for Linux on x64, as a package for Debian and Ubuntu: sudo apt install ./jason-desktop-linux-x64.deb |
jason-desktop-linux-x64.AppImage |
the same application for Linux on x64 as one file, to make executable and run from wherever you keep it, on a system that lets it run its sandbox |
latest-linux.yml |
the Linux desktop's update feed: this version, the deb's and the AppImage's names and their SHA-512 |
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.
Desktop
Jason Desktop is a window onto this same Jason, in five packages: Windows on x64, macOS on Apple silicon, macOS on
Intel, and Linux on x64 as a deb and as an AppImage. Each carries this release's executable, signed as the archive's
is, with LICENSE and THIRD-PARTY-NOTICES beside it, and talks to it as the CLI does. On Windows, run
jason-desktop-windows-x64-setup.exe; the installer, its uninstaller, Jason.exe and the jason.exe it carries are
each signed with Reply's certificate and timestamped. On macOS, open the dmg for your Mac and drag Jason into
Applications; the application, the jason it carries and the dmg are signed with Reply's Developer ID and notarized,
and the application and the dmg are stapled. The Intel application's jason is built and signed as the Apple silicon one is, and started once under
Rosetta where the release's runner has it; the test suite does not run on an Intel Mac.
On Linux, install the deb with sudo apt install ./jason-desktop-linux-x64.deb; it puts Jason in /opt/Jason and
in the applications menu. Or make the AppImage executable, chmod +x jason-desktop-linux-x64.AppImage, and run it
from wherever you keep it; it is built on the AppImage runtime that needs no libfuse2. Jason never runs without
Chromium's sandbox, so the AppImage needs a system that lets it run its sandbox. It is built so that on Ubuntu 24.04
and later, as shipped, the AppImage says so, does not start, and names the deb, whose install brings an AppArmor profile
for its sandbox there; this release's build machine started both packages sandboxed, and neither has yet been seen on
such a machine. Neither is signed, and neither is the jason they carry, as the Linux archive's is not. Checked beside the deb,
sha256sum --check --ignore-missing checksums.txt proves it is the file this release published, not who built it;
checked beside the AppImage, it proves the same of the AppImage and no more. The jason they carry needs the ICU
library (libicu), as the archive's does.
The desktop updates itself from the latest release's latest.yml, latest-mac.yml or latest-linux.yml, on your
word, and to stable releases only. A candidate's feed files stay on the candidate's own page, which never becomes the
latest release, so an installed desktop, a candidate included, never moves to a candidate.
Installing an update restarts the runtime: the runtime the application carries is stopped first, with
jason runtime stop, as the menu's Restart Jason and Its Runtime to Install says, and the new version starts it again
when it opens. A runtime that does not stop leaves the update uninstalled, saying why, and a runtime started from
another jason is never stopped. Before the update installs, the application as it was is copied under
~/.jason/desktop/rollback/<version>/, and the Jason menu names that copy until the next update replaces it. Nothing
puts it back by itself: to go back, quit Jason and put that folder back in the place of the installed application by
hand. That puts back the previous application and the jason it carried; the data directory stays as the newer
version left it.
On Linux the updates are built as follows, and not yet seen on a real machine. The deb's update installs the new deb
with dpkg, which asks for an administrator's password every time, through the first of gksudo, kdesudo,
pkexec and beesu the system has, else sudo: an account that cannot give one cannot install the update, and
Jason stays open and says so. A deb update keeps no copy; to go back, install the previous release's
jason-desktop-linux-x64.deb the same way. An AppImage update replaces the file where it is, so you need to be able to
write to its folder, and keeps the file as it was under ~/.jason/desktop/rollback/<version>/.
Uninstalling the desktop on Windows stops the runtime the application carries first, and removes nothing when that
runtime does not stop. It then takes off what it put there - the jason command it placed on the PATH, Open Jason at
login, and the runtime's logon start when that start names the application's own folder - and leaves the data
directory (~/.jason), the harness root (~/Jason) and the updater's cache, %LOCALAPPDATA%\jason-desktop-updater,
saying so. On Linux, choose Remove What Jason Placed… in the Jason menu first: it stops the runtime the application
carries and takes off what Jason placed, the jason command, Open Jason at Login and the runtime's start at logon,
then says what removes the application. sudo apt remove jason-desktop removes the deb, and deleting the file
removes the AppImage. What stays is the data directory (~/.jason), the harness root (~/Jason) and the updater's
cache, ~/.cache/jason-desktop-updater. On macOS, choose Remove What Jason Placed… in the Jason menu first, then move
Jason.app to the Trash. What stays is the data directory (~/.jason), the harness root (~/Jason) and the updater's
cache, ~/Library/Caches/jason-desktop-updater.
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.42.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.42.0/install.sh | sh -s -- --version 0.42.0 --no-modify-path& ([scriptblock]::Create((irm https://get.jasonharness.ai/releases/download/v0.42.0/install.ps1))) -Version 0.42.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.
For scripts that call the CLI
Since 0.34.0, jason suppression remove, jason route set, jason route unset and jason role set-profile take no
default actor: outside a run, a command that does not name who acts with --actor human:<Name> exits 2 before any
request.
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, apart from the desktop's installer
and Mac packages, as "Desktop" above says.
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.