Repository navigation
Jason 0.41.0
Jason 0.41.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.40.0
This release is about a new person's first minutes and the numbers they see: three lines pasted into your AI install Jason and hand the ready installation to a new quick-start skill, which asks one question and drafts your first campaign; the console opens in any browser tab, with the desktop or without it; Settings gains a section for your name and tone; the demo opens on its sample in seconds; and the Dashboard counts over one period you choose, with replies by category and daily trends, read through a new reply.count.
- Three lines install Jason and take you to a first campaign. The README's Quick start now opens with a prompt to paste into your AI: "Install Jason by following https://get.jasonharness.ai/install. When it reports Ready, start its quick-start skill and take me to my first campaign. If anything stops you, ask me directly and tell me why." Those three lines are your yes to the install, so an agent given them installs without stopping to confirm each step; it asks you only for an act the install guide marks Ask first., or where its own checks stop it. An agent given only the link asks before the install, as before. The README's longer install text follows under "What the install does", and the handbook carries the same three lines. See the install guide.
- The quick-start skill. A new runtime skill,
quick-start, takes a ready installation to a first campaign. It asks one question, what you sell and who should buy it, where a line about yourself and how you write is welcome and never required; it reads which provider your email and LinkedIn go through instead of asking you; it makes a draft of your first campaign and says the plan in one message, the goal, who it will look for, the channels and how it will write, ending "Say what to change, or say go." It reads which accounts are connected only after you say go, and a first message is never sent without your yes. An agent that finishes an install now hands over in one order: where your files are, what it ran and changed, what is not done now with its command (starting the runtime at logon, and skills for other agent hosts), and then the quick start, whose question comes in a message of its own. Installed Jason yourself? Ask your agent to start Jason's quick-start skill. See what the quick start does. - The console in any browser tab.
jason ui opennow opens the same console the desktop's window draws, in place of the browser's older shell: the Dashboard, Needs you, People, Agents, Accounts, Performance, Activity, Work items, System, Settings and the search, everything that reads the runtime. Where the chat would be, the page says that the chat is part of Jason Desktop and links to the releases page; what only the desktop does is drawn off, with "This needs Jason Desktop." A tab the desktop opened, through Open in, then Browser, now shows the whole console too, with the chat as before: it sends only to a chat in Ask first or Plan only and never approves, and what only the desktop's window may do, the Demo | Live switch, the account acts of Connect and Accounts, the other access modes and the take-back of Full access, is drawn off with "Done in Jason Desktop's own window." Open in is not offered inside a tab. The runtime gains no route for either. See the browser UI's page. - Your name and tone, in Settings. A section, Your name and tone, in two parts, each saved on its own: Who writes, your name, job title, company and the grammar forms for the writer, Neutral unless you choose another; and How you write, a few words and a formality. They are the named preferences
sender.identityandtone_of_voice, saved through the Runtime API as you, so the section works in the desktop's window and in any tab alike. A save reads what is set again and changes only the fields you changed: a field set from a terminal in the meantime is kept, and so is everything the form does not show; with several senders set, the form edits the first and says so. Removing a value stays withjason preference unset. In the demo the section says it is set in Live. - A one-time note on Start. In your own installation, once a chat exists and neither your name nor your tone is set, Start shows "Jason writes in your name." with Set preferences now, which opens that section, and Not now, which closes the note for good. Nothing else reminds you.
- The Dashboard counts over one period. A Period menu holds 7 days, 30 days, 3 months, 6 months, This year and Custom, with From and To; every tile and card counts over it, in calendar days of your time zone, ending now. The Dashboard opens on 30 days each time. Needs you counts what waits now, whatever the period.
- Interested, Meetings booked and Replies by category. Interested and Meetings booked now count the conversations whose replies the roles judged
interestedandmeeting_booked, with a dash where none is, and a hover that says what each counts; Bounce rate still shows a dash. A new card, Replies by category, lists every category the roles' verdicts use, with its conversations and replies. These count judged replies, each in the period it arrived in: a reply no role has judged yet is not among them, so they are not the Replied tile's people. - Daily trends. Beside Contacted, Replied, Interested, Meetings booked and each category, a small trend compares the last 24 hours with the 24 before them, whatever the period: a green "+N", a red "−N" or "±0", with a tooltip saying what is compared. Reply rate has none. Show daily trends in the Dashboard's header turns them off and on; the desktop remembers the choice, and a browser tab shows them and does not remember.
jason reply count. A new read of the Runtime API,reply.count, and its verb,jason reply count [campaign-id...] --since <moment> --until <moment>: for each campaign named, or every campaign not archived, and in total, how many replies the roles judged under each category word, and in how many conversations. The window is held to each reply's own arrival,sinceincluded anduntilnot, so a reply judged days later counts in the window it arrived in; one reply counts once, under the latest verdict recorded on it.--humanshows one row per category for each campaign, and the total last. The desktop's chat runs it without a card in Ask first and Plan only, as a read. See the Runtime API.- The demo opens on its sample in seconds. The sample is now made once, when the release is built, and every desktop package of the release carries it. The first start of the demo, and each Start the Demo Over, places it with
jason importbehind Preparing the demo…, in a few seconds where making it took over a minute. It is still made at the start when the archive is older than twenty-one days, by the moment the archive itself records; in a desktop built outside a release; and when the placing fails, after what it placed is taken away. See the desktop guide.
Upgrading from 0.40.0
Nothing stops, no setting is renamed and no database migration is added.
- The executable:
jason update apply, or run the install line again. After it,jason skills updateandjason ui installfollow: the first brings this release's skills, the quick-start skill among them, and the second the console thatjason ui opennow opens. - 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.40.0, so there is nothing to replace with
jason plugin install. - 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. The desktop places the page of its own version where the runtime is the one it carries, the Dashboard's switch for daily trends is remembered by this release's desktop, and the demo's prepared sample comes in this release's desktop package.
jason ui openopens the console. A tab it opens, and a bookmark of the page, show the console in place of the browser's older shell, once this release's UI is placed.- From 0.39.x or earlier, the notes of each release in between apply as well.
Known issues
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.41.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.41.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.41.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.41.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.41.0, which jason plugin install telegram places in ~/.jason/plugins/telegram |
jason-ui.zip |
the browser UI's package: ui/ built at v0.41.0, which jason ui install places as the default UI |
jason-skills.zip |
the skills' package: skills/ at v0.41.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.41.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.41.0/install.sh | sh -s -- --version 0.41.0 --no-modify-path& ([scriptblock]::Create((irm https://get.jasonharness.ai/releases/download/v0.41.0/install.ps1))) -Version 0.41.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.