Repository navigation
Jason 0.22.0
Jason 0.22.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.21.0
- A send can wait for its moment.
message.sendandsocial_invitation.sendtake an optionalsend_after: the
moment the message goes out after, with its offset, such as2026-11-03T09:00:00-05:00. A moment without an offset
is refused when the work item is written. The approval shows it, aftersend after:. A send's work item now
succeeds once the provider has taken the send: its result'sstatusissentwhere the provider sent it within the
call, andacceptedwhere it took it, for now or for the moment named. Whether the message went is read afterwards,
never from that item. A plugin that does not listsend_afteron the send's channel is never handed it: the claim
refuses the work withargument_unsupportedbefore anything runs, so a moment is never dropped and sent at once.
Through Reply, a moment goes on an email or any LinkedIn message, an InMail and a voice message among them, and on a
LinkedIn invitation. - A send the provider holds can be read and taken back. Two new operations,
message.statusandmessage.cancel,
name a send by the work item that made it,{"send": "wi_…"}; the runtime supplies the reference the provider gave
that send, so neither reaches a send another campaign or another route made.message.statusanswersqueued,
sent,cancelled,failedorunknown, the last for a send the provider attempted and lost track of, which may
have gone; with it, when the send went, the message it became, and the provider's reason and code for a failure.
message.canceltakes back a send still held; a second cancel succeeds as well, and a send that went or failed is
refused withsend_not_pending. A cancel runs in a paused campaign, as stopping is the protective half of the work.
When a read finds a send gone, the chronicle says so once, asmessage_sent_observed; the campaign manager is woken
by it only whereManager:Triggerslists it. Twenty-four operations are published now. - A send whose answer was lost is repeated only where that is safe. Until now such a send was final. A plugin that
sends under the work item's key, and says so in its manifest'ssettles_by_key, may now be asked again: a provider
that keeps the key answers a send it already took with that send, and sends nothing twice. The claim makes the repeat
only under the package, the account and the arguments of the attempt that may have sent, and otherwise refuses it
withprovider_answer_lost, final, saying that an earlier attempt may have reached the person. Through Reply both
sends are repeated this way within 23 hours of the first attempt that may have sent; past that, or where Reply
cannot be asked, the repeat issend_not_settledand nothing is sent. - An email through Reply can be timed by one of the account's sending schedules.
message.sendtakes, in the
provider's own object,"provider": {"schedule_id": "<id>"}: theidof a scheduleschedule.listnames, written
as a string of its digits. Reply holds the email for the schedule's next opening, or its first opening at or after
send_afterwhere both are given, and since Reply only estimates that moment the result'saccepted_foris null.
Any other shape of the object is refused before anything is called, withprovider_input_invalid. A LinkedIn
message cannot be timed this way, as the known issues below say. The
Reply plugin's page says how. - Replies through Reply are read from Reply's change feed. One read per account lists the threads that moved, in
place of walking every thread of every campaign page by page, once per cadence. The walk stays as the fallback, and
takes an account back whenever its feed is not offered or stops answering;jason events sourcesshows each
account's source and whether it is healthy. What the feed gives Jason is identifiers, moments and Reply's flags,
never a subject, a preview or a name. - A LinkedIn message and an InMail can be templates the provider fills in, as an email already could.
compose: templatenow covers a LinkedIn message's text and an InMail's subject and text. A plugin is handed a
template only on a channel its manifest lists undertemplates; on any other channel the claim refuses it, with
template_not_offered, before anything runs. The Reply plugin writes all three in Reply's syntax: the sender's
first name and full name become Reply's LinkedIn variables, andsender.addressis written in as the sending
profile. A template namingsender.last_name, which Reply's LinkedIn account does not carry, is refused with
template_unsupported, and a voice message stays a final text. You approve the template and its example, as for an
email; the text as Reply filled it in is read afterwards frommessage.status, where Reply gives it. The copywriter
and both planners now write a template for any of the three. - The macOS executable is signed with Reply's Developer ID and notarized by Apple. A browser-downloaded archive
runs on its first start without Gatekeeper refusing it; that first start needs the network, as the section on what
is signed below says. The Linux and Windows executables are not signed, and the checksum stays their only
provenance. - This release publishes the Reply plugin 0.14.1, which needs reply-cli 0.17.2. Every call it makes tells Reply it
came through Jason: reply-cli putsjason-harness/<version>at the front of its User-Agent, the runtime's version
without its build metadata, and nothing that names the machine or the person. Where an account's Reply does not offer
what a work item asks for, the plugin answerscapability_not_offered: final, nothing done, and the manager skill
takes it as a reason to do the work another way or tell you. - For plugin authors. Two codes are reserved beside every operation, and no document declares them:
provider_input_invalid(validation), for a provider object the package cannot read, andcapability_not_offered
(permanent), for what the provider does not offer yet. Neither clears a provider block. The manifest takes three
new keys atmanifest_version1:arguments, the channels each argument is taken on;settles_by_key; and
templates. A runtime older than 0.22.0 refuses all three withunknown_field. Every operation document now names
itschannel_argumentsandchannel_templates, and the claim has twenty checks in one published order.
The plugin guide and
the contracts set them out. - The skills know the new answers. The campaign manager asks after one send and takes one back, reads the
person's thread before any new send when a send isunknown, and treatscapability_not_offeredand
template_not_offeredas final; the troubleshooting skill tells apart a capability the provider does not offer, a
provider object it refused, and a refusal of a send that may already have reached the person, which nobody repeats
until the provider has said the earlier attempt did not act.
Upgrading from 0.21.0
- The executable:
jason update apply, or run the install line again. Installed with Homebrew, it is the three
linesjason update applyprints instead:jason runtime stop,brew upgrade jason,jason runtime start. The
install line and Homebrew place the executable alone, so after either,jason skills update,jason ui install
andjason plugin install reply --replacefollow. - The Reply plugin: with the package a release published installed as it came, 0.10.0 from 0.21.0,
jason update applyreplaces it with 0.14.1 and keeps the package it replaced under the data directory's
update/previous/plugins/reply. A package edited on this
machine is left as it is, and so is the package under the install line and Homebrew:
jason plugin install reply --replaceswaps it for 0.14.1. Until it is replaced, the old package under 0.22.0 has
its email templates refused withtemplate_not_offeredat the claim, since it lists notemplates, and offers none
ofmessage.status,message.cancelandsend_after. - reply-cli 0.17.2 or newer: the Reply plugin 0.14.1 asks for it, and an older CLI makes the plugin
unavailable
withexecutable_incompatible, so work routed to it fails at the claim withplugin_unavailableand runs nothing.
Update it withnpm install -g reply-cli, thenjason plugin reload. - The data directory: this release adds one database migration, an index that lets the chronicle say once that a
send went. The first start on 0.22.0 runs it after taking a backup, as every migration does. Your projects,
campaigns, work items and chronicle stay as they were. - What reads or is refused differently:
- Through Reply, a send's work item ends with
statusacceptedwhere Reply holds the send rather than sending it
within the call. Bothsentandacceptedare done; neither is a reason to send again. - Through Reply, a
message.sendwhoseproviderobject is anything but{"schedule_id": "<id>"}is refused with
provider_input_invalidbefore anything is called; the package 0.21.0 published, 0.10.0, ignored the object.
The other operations still ignore it. - A template on a channel the routed plugin's manifest does not list under
templatesis refused with
template_not_offeredbefore anything runs.
- Through Reply, a send's work item ends with
- Skills: the update redeploys them wherever a deployment was recorded; after the install line or
brew upgrade jason, runjason skills update.
From 0.19.x and 0.20.x the same applies, and the update is one apply. From 0.18.x or earlier, Jason's own installation
updates through 0.19.0: jason update apply --version 0.19.0, then jason update apply; from a build older than
0.18.0, the first of the two can stop at started, as the first known issue below says.
Known issues
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.
Reply's routes behind this release's send features - a send's moment and its sending schedule, reading and cancelling
a send by its reference, and the inbox change feed - reach Reply's accounts on Reply's own schedule. Until an account's
Reply has a route, the Reply package answers capability_not_offered for that operation or argument, and the account's
replies are read thread by thread in place of the feed, as its README says; nothing in Jason needs updating when the
route arrives.
Through Reply, Jason sees only a contact's first reply. Reply marks a contact who replied as finished and stops
detecting that contact's later replies, so a later reply from the same contact never reaches Jason.
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.
Through Reply, a sending schedule times an email only: Reply refuses a schedule on every LinkedIn direct send in this
version, so a LinkedIn message that names one is refused before anything is called, with provider_input_invalid.
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.
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 the two packages, 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.22.0, which jason plugin install reply places in ~/.jason/plugins/reply |
jason-ui.zip |
the browser UI's package: ui/ built at v0.22.0, which jason ui install places as the default UI |
Each archive holds the executable, LICENSE (the runtime's licence; the repository's MIT does not cover the
runtime) 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 UI's package is
placed by jason ui install, which the install guide runs and jason update apply runs at its end.
On Linux the executable needs the ICU library (libicu), which desktop distributions carry and minimal
images may not; the install script stops, with the runtime's own message, rather than install a program that does
not start.
Installing
One line, on macOS and Linux:
curl -fsSL https://jasonharness.ai/releases/latest/download/install.sh | shand on Windows, in PowerShell:
irm https://jasonharness.ai/releases/latest/download/install.ps1 | iexBy installing Jason you accept the Jason Runtime Licence:
https://github.com/reply-team/jason-ai/blob/v0.22.0/LICENSE-RUNTIME.md. If you do not accept it, do not
install Jason.
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://jasonharness.ai/releases/download/v0.22.0/install.sh | sh -s -- --version 0.22.0 --no-modify-path& ([scriptblock]::Create((irm https://jasonharness.ai/releases/download/v0.22.0/install.ps1))) -Version 0.22.0 -NoModifyPathUpgrading from 0.1.0
If this machine ran 0.1.0 with autostart enabled, run jason runtime autostart enable or disable once from an
ordinary prompt — if that answers Access is denied, follow its message first — then jason runtime stop once, then
jason runtime start (or sign in again, with autostart enabled). 0.1.0's logon task started a runtime that outlives a
sign-out and holds the data directory; until it stops, the runtime this version starts at sign-in finds the directory
taken and exits.
Checking a download by hand
sha256sum --check --ignore-missing checksums.txtOn Windows, compare Get-FileHash of the archive with its line in checksums.txt.
If you then put the executable in place by hand, keep LICENSE and THIRD-PARTY-NOTICES beside it, named
jason-LICENSE and jason-THIRD-PARTY-NOTICES.
What is signed
The macOS executable is signed with Reply's Developer ID and notarized by Apple. 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, and Gatekeeper checks the
notarization with Apple, online, the first time the executable runs. The ticket is not stapled to the file, which a
bare executable has no place for, so that first run needs the network.
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. Gatekeeper accepts any notarized Developer ID, so it is that name and that team id, not
the acceptance, that say the executable is Reply's.
The Linux and Windows executables are not signed, and nothing else a release carries is either. On Windows, an
archive a browser downloaded carries the mark of the web, and the executable unpacked from it is stopped by
SmartScreen the first time it runs: install.ps1 clears that mark from what it unpacks.
Both scripts check the archive against checksums.txt before unpacking. On Linux and Windows that check is the only
provenance there is; on macOS the signature says who built the executable as well.