skip to content
TerminalHire documentation

Post a paid task

You can start with a repository, a spec, a conversation, or a rough idea. Save the project context first, or go straight to a task on an existing repository. A posting turns the task you are ready to hand off into something a developer can find, claim, and finish — without you handing over repository access to a stranger first.

This is the other half of claims. That page is written for the developer doing the work; this one is for the person paying.

Who can post

Anyone signed in. Posting is tied to your GitHub account, so there is no separate login, no company profile to fill in, and nothing to apply for. The one account that cannot post is one we have revoked, and that is not reversible from inside the product.

Sign in on the web at /dashboard. If your account only posts work and you have a project, you land on that project's Home. It opens on Waiting on you, and its All tasks tab lists every task. With no project yet, open Tasks. If you also take work, it is Posted by me under Work.

Three things gate the moment you publish, not saving project context. Outside the pilot described below, publishing refuses by name until each is in place:

  • the TerminalHire Poster GitHub App installed on the repository you are posting about — that is the App's name on GitHub; look for it under that name
  • a saved card
  • a confirmed contact email

During setup, sending the email link keeps you on the email step until you confirm. Leave that tab open: it checks automatically and moves to the next unfinished step. The email confirmation page also has a Continue setup link. If your mail browser isn't signed in, sign in with the GitHub account you started with to resume setup.

You can skip a step for now and return to it by choosing it in the setup checklist. Any unfinished step is available there, including Payment details. Skipping does not complete a step: a saved card, confirmed email and repository access are still required before publishing, except where the pilot below waives the card and email.

You can ask before you draft anything: publish_requirements names whichever of the three is still missing, and changes nothing.

Publishing during the pilot

While the pilot runs, an account on the pilot list can publish a task with no saved card or confirmed email, and the TerminalHire team can publish for that account a task the team prepared on its project. Either way the account's membership must be live and its credit must cover the full price at that moment. Credit is checked for each publish and is not set aside, so several tasks can each pass against the same credit. Every other publishing check still runs, including GitHub App access to the repository.

Such a task is charged at acceptance, from credit only: if credit no longer covers the price then, the acceptance is refused and nothing is charged. It stays credit-only if you save a card later. publish_requirements still names the card and email as missing.

Setting up from the terminal

terminalhire setup walks the same checklist without the setup page. It opens your browser to sign in with GitHub and approve a connector for this terminal, the same approval an AI tool asks for. Tick act on my behalf there: the card and email steps need it, and so does publishing from the terminal. Setup then opens the GitHub App install, opens the payments panel on your dashboard to save a card (the card never passes through the terminal, and saving it charges nothing), and asks for your email address and mails a confirmation link to it. Each step turns ✓ when the server sees it done. If setup cannot read the checklist, the rows show ! and it does not say you are ready.

  • If the GitHub App covers more than one of your repositories, name the one you post from: terminalhire setup --repo owner/name.
  • The email step needs an interactive terminal. Confirmation mails are limited per account, and a refusal says how long to wait.
  • The email step is for first-time setup. Once you have a confirmed address, change it in the browser, under Settings on your dashboard.

Run it again to pick up where you stopped, or terminalhire setup --status to see the checklist. terminalhire setup --reconnect approves a new connector; the old one keeps working until you remove it under Settings → Agent connections.

The connector is stored encrypted on your machine. If Claude Code and the terminalhire command are both installed, setup offers to connect Claude Code, and asks first. It registers a helper, terminalhire connector-header, that Claude Code runs when it connects to get the key. The key stays in terminalhire's encrypted store and is not written into Claude Code's config.

What a terminal can publish

A linked CLI login (terminalhire link) still cannot publish. It lasts thirty days, and that is too long a key to leave lying around for something that spends money. What can publish is a connector you approved with permission to act, and terminalhire setup is one way to create one. With it, terminalhire post submit saves a draft to your account, and terminalhire post publish <draft> --price <usd> shows what a claimant would receive and publishes only when you type yes. Both need an interactive terminal. Publishing checks repository access, your card and your email again for itself. If the server no longer accepts the stored connector, post submit removes it, says so, and sends the draft without it.

Before saving a connected terminal's draft, post submit shows the matching project record and its confirmed revision, then prints the server's attachment receipt. An unconfirmed record needs confirmation on its project page. To post without the record, run terminalhire post submit <draft-id> --no-project; the printed network body includes projectContext: null. This opts out of project context, while membership payment rules still apply. The precheck is advisory; the server checks again when saving the draft.

Without a connector, terminalhire post still drafts, shows, edits and lists drafts on your machine, and terminalhire post submit sends one to the server and hands back a browser link to confirm. Anonymous drafts do not automatically attach a project; run terminalhire setup before submitting to carry the saved record. Accepting finished work and paying stay in the browser either way, except that a posting set to accept automatically is accepted and charged 24 hours after a missed decision deadline.

After your first successful publish, setup ends with your live posting and a completed checklist. Choose Open your posting to enter its workspace. If your AI publishes through the connector while the draft is open in your browser, the page catches up automatically when you return. The draft link also takes you to the posting it created.

Writing the posting

Starting with an idea, a spec, or code held by a builder

Start with Project context. You can save a project before you have a repository, a card, or a complete spec. Your agent can use begin_project on the poster MCP, ask the returned questions in your conversation, and resume later with list_projects and get_project.

The interview covers intended users, desired outcome, a concrete workflow, the first deliverable and its exclusions, acceptance evidence, operating constraints, available code and a verification plan. Reuse facts from your spec and authorized code. Proposed or disputed answers stay visible until you review them; questions that affect a later task can remain open. A read-only connector saves answers as proposed and cannot confirm or dispute one, or change a confirmed one. You confirm them on the project page.

Choose the repository owner and destination before connecting it. Your agent can create the repo using its authorized GitHub tools, or you can use GitHub in the browser. For builder-held code, keep the existing work and agree where it belongs. Install the TerminalHire Poster App on that repository, then confirm the record on its project page. TerminalHire keeps the record and tasks read it from there, so nothing has to be committed first. Confirming notes the latest commit on the delivery policy's confirmed base branch (or the default branch when no base branch is recorded). You can add the exported PROJECT_CONTEXT.md to the repository later, through your normal review. In the browser, the Repositories tab of the project's Context walks these steps under Connect a GitHub repository: create the repository, give TerminalHire access (GitHub brings you back to the project), then connect it to the project. Organization repositories can take a moment to appear after you give access.

New tasks look up the confirmed project record for their repository. A project can span several repositories; the task still targets the repository you choose. One repository in the project's list holds its record. The first repository added to a project takes that role, and you can move it to another under Repositories in this project. If you remove the one that holds it, you choose the next. If more than one project covers the task's repository, choose which project the task belongs to. The composer and agent receipt name the attached project and revision. You can explicitly leave the record out, but that does not remove an active membership's requirement for manual acceptance.

The context is included in the developer’s task handoff; later project edits do not rewrite an existing task. On a member project, the team can add your confirmed record to an open task that went out without one, if the task needs approval and has no claims. It goes into the private task, which a developer reads after you approve them; the title and public description stay as they are. The normal repository, disclosure, card and contact checks still apply. A context-only repo has a real starting commit, but may have no runtime or tests: the first build task needs a runnable test command and acceptance tests.

“Project context” describes the task you want built. The Contribution Dossier describes a developer’s past work.

Your project between tasks

Your project page has four tabs. Overview shows what in this project waits on you, its tasks by state, the three newest notes, and your membership and credit. Tasks lists every task with who moves it next, and your team's drafts that are not published yet. Tasks that need you come first, then tasks with a developer, tasks waiting for one, tasks being paid or finished, drafts, and closed tasks. Context is one page with five tabs, and the open tab is in the address. Overview is what the project is. Not determined lists what nobody could tell, and Answer opens a box in place. Under it is Confirmed: the lines developers on new tasks receive once you press Confirm Context. That button is on every tab, and is offered when every answer is confirmed, the project has a repository and this version is not confirmed yet; the line under the page's title then reads Action required. Edit changes one line. Proposals is what waits on you, with the count in the tab's name, or No proposals waiting. Approval required lists each value nobody has confirmed, with where it came from: Accept it or Edit it, and one button accepts every line read from your repositories. Disputed shows two values for one line, and Use this keeps one; a disputed value with nothing against it has Accept and Edit. Proposals for repositories and services are listed under them. Repositories lists the project's repositories, one line each, and the services it uses. Notes holds the project's questions, earlier notes and what you have added. Delivery is how work on the project is tested and delivered, and Edit the record there opens the record's form.

On a project with a live membership your team can record the project for you. It accepts its proposals into the record and confirms that version, and tasks can use it at once. You don't need to do anything. We put a notice on your project page and, unless you have turned our emails off, send you an email, and a developer reads the record only after you approve them. If something is wrong, change it and press Save and use this version: later tasks use your version, and a task already posted keeps the one it carries. Your team does not record over a value you wrote or accepted: its proposal waits for you. Save context alone keeps a draft, which no task uses. Everywhere the record's status shows, it says whether your team recorded it or you confirmed it.

An answer or policy field saved as proposed, by your agent or by you, is already on the record as proposed, and it joins the same review under Saved value, unless it holds only placeholder text. Accepting it confirms it, and Dispute marks it as disputed on the record, which makes a new revision.

The page groups proposals into sections by topic and opens the next one waiting. Accept or dispute each field with Accept proposal and Dispute, take a whole section with Accept this section, or use Accept all and confirm. One action makes one new revision of the record, and any services and repositories it accepts follow one at a time. A proposal that cannot apply stays as it was and the page says why: it is out of date, it was already decided, or another proposal covers the same field, in which case accept the one you want on its own. A proposal your team takes back shows Closed by the team and leaves the record as it was.

Accepting publishes nothing. Confirm the record on the project page, or let your team record it on a member project, before using it for another task. Dispute on a team proposal leaves the record unchanged. Team notes are observations, not instructions.

Optional policy fields record where you test, who merges, the test command, runtime, service images, review mode, off limits and escalation. Only confirmed policy fields appear in the export. Confirmed review and test settings prefill a task draft; you can change them before publishing, and the existing publish checks still apply. In the dashboard composer, Use a confirmed project lets you choose the record. The policy's base branch controls where context confirmation reads the file and prefills new tasks. An explicit task branch takes precedence; clearing it explicitly uses that repository's default branch. Review the repository-access notice again after changing the branch.

Membership projects also show the existing account credit balance and the membership period. Under the balance, the panel lists what makes it up: each monthly allowance with what is left and the date it resets, credit blocks with the date they stop being spendable once a membership has ended, and any credit held for a payment in progress. Confirmed subscription payments add the $150 monthly allowance automatically. Additional credit blocks are purchased by invoice. An allowance lasts until its reset date; blocks stay spendable while a membership is active and for 180 days after it ends. Membership-linked postings publish with automatic lapse acceptance off. While membership is active, posting edits cannot turn it on. The policy records delivery guidance; it does not enforce off-limits paths or operate your environments. Tier and baseline progress describe the recorded onboarding state.

The membership panel, the payment card in settings and the confirmation page each say what you pay, when, and from what. Publishing charges nothing; the posted price is charged at acceptance. Task credit pays first. If it covers the whole price, your card is not charged. With no credit, your card pays the whole price. A posting set to accept automatically is accepted and charged 24 hours after a missed decision deadline, to your card only; while your available task credit covers the whole price, it waits for your decision instead.

What happens to credit that covers only part of the price depends on whether TerminalHire's credit ledger is in use. When it is, partial credit pays its share, your card is charged the rest, never less than $0.50, and any available credit holds back the automatic accept. When it is not, partial credit is not used, and your card pays the whole price. The confirmation page and the membership panel say which rule applies when they can read your credit, and the confirmation page shows the credit you have available. The payment card says only what holds under both rules.

The posting's fields

Six fields carry the weight:

Field What it is for
Title One line, at most 140 characters.
Spec What a developer actually works from. Worth ten minutes.
Price Whole dollars. Below the minimum, the refusal names it.
Repo owner/repo. Mark it private if it is.
Stack tags Up to 12, 40 characters each. They decide who sees this.
Claim mode Open, or approval-only.

Optional: a link to an existing issue, an effort estimate, and a note about whether you welcome AI-assisted work. The effort estimate reaches the public index as small, medium or large, whatever words you put in.

Reference links. One URL per line in the reference-links box — a Loom walkthrough, a Figma frame, a gist. Your assistant can attach them too, and is asked to prompt you. They appear on the developer's page as links, beside the task, for anyone the posting delivers to. Six at most.

https: only, and that is the whole rule. A link on any other scheme is refused, and the refusal says which one — "the 2nd reference link must start with https://" — counting links from the top, so you can fix it rather than hunt for it. Blank lines are ignored and are not counted.

Links to Loom, YouTube, Vimeo, Figma, GitHub and gists are labelled with what they are. A host we do not recognise still works — it just gets no label, because we have not looked at the page and will not say we have.

They are not embedded and they are not fetched. A reference link is a link.

Set them when you post. They cannot be changed afterwards — the revision record has no column for them, and a field that took your keystrokes and dropped them at the save would be worse than one that says so.

Tags are how developers find you. Matching runs on tag overlap, so a posting tagged rust and postgres reaches people who work in those; an untagged one reaches nobody in particular. Write them the way you would write them on a job post.

The spec is the deliverable. A developer decides whether to claim by reading it, and then works from it. A one-line spec produces one-line work, and the price you set does not fix that.

A posting needs a public task description. It is what a developer reads before claiming. Publishing refuses one with no Outcome. Scope and Acceptance are not required, and a developer can judge the task better with them:

## Outcome

What is different when the work is done.

## Scope

What is included, and what is not.

## Acceptance

How you will judge the result: tests, behaviour, review criteria.

Outcome needs at least five words or 25 characters, and a placeholder such as TBD or n/a does not count. ## Deliverable, ## Project context, ## Constraints and ## Open questions are optional too. The headings Goal, Objective, Scope of work, Acceptance criteria and Definition of done count as well.

New task has a field for each, and Post task stays off until the title and Outcome are written; the bar names what is still to add. A draft from your assistant with no Outcome is not published, and the refusal says so; on the confirmation page each section has its own Edit or Add button, and that is where you fix a draft. An edit cannot take the Outcome out of a description that has one.

A developer is shown only the sections you wrote. A section you left empty is not shown to them, on the claim page or in the task file their workspace gets.

From an assistant, send it as publicBrief with outcome filled in, and scope and acceptance when it can write them. draft_posting saves a draft without one and says what is still missing.

Work no test suite can judge. For docs, design, config or anything else a test suite can't judge, choose "No automated tests" under Options on the New task page (the confirm page calls it "No automated tests — I'll review the work myself"). From an assistant, send reviewMode: "poster" to draft_posting or confirm_posting. We then don't look for a test command, and we don't run tests on what is submitted: no workflow of ours is added to the claim branch and no run is queued. You read the work and decide whether to accept it. Your posting's decision terms apply as they do to any other posting. You can't name a test command on the same posting, and the choice can't be changed after publishing; withdraw and post again instead. Your own repository's workflows may still run on the claim branch or its pull request. We don't judge their results, but we do read their configuration for potential secret exposure, as described under "The work comes back as a patch".

Otherwise, a posting needs a test command. When you publish, we read the repository at the commit being posted and look for the command that runs its tests. If we find one, the confirmation shows it and asks nothing. If we find none, publishing stops and names the files we looked in, and you type the command yourself — one line, such as npm test or pytest. When we also cannot tell the language, pick it from the list beside the field. If we found a language, or a command that runs only the tests, you cannot replace it: publishing refuses one you send, and a draft's is dropped. If the command we found also runs checks such as lint, formatting or typechecking beside the tests, you may name one that runs only the tests, and verification runs yours instead. From an assistant, publish_requirements and confirm_posting say when this applies.

When your code sits in a subdirectory. If the repository root has no manifest such as package.json, we use the directory your CI names for its test step with working-directory. With no directory in CI, we use the one top-level directory that holds a manifest, unless the CI test command already goes there itself; with several, publishing asks for the language as above. Install and test then run from that directory, and developers see the command as cd auth-service && npm test. A path we cannot use, such as an absolute one, one with .. or a ${{ }} expression, is ignored and publishing asks. A command you name runs from the repository root, so start it with its own cd.

The command you name must be plain, because developers see it before they claim: a build or test tool, or a ./ script, followed by words, flags and relative paths, such as npm run test:ci. It may start with a cd to a relative path with no .. in it (cd apps/web && npm test) or with plain settings such as CI=1 npm test, name a workspace (npm -w @scope/web test), and give a flag its value with = (--reporter=dot). Publishing and editing refuse anything else, and a draft's is dropped. Put pipes, quoting or $ references in a package.json script and name the script. A command that looks like it carries a secret is refused too: a token-like value, a flag or setting named like a key, token or password (--token=abc, API_KEY=abc), or any word that is not a short plain word or a path made of them. A short plain word is 24 characters or fewer of lowercase letters and digits, or letters only, such as a test name, and one is shown wherever it appears. A file name made of such a stem plus a lowercase extension of up to 8 letters and digits, such as test_user_authentication.py, is shown too. A secret written in either form would be shown. Keep secrets in your CI settings, never in the command.

Before they claim, developers see whether we found the command or you named it, and they see the command itself unless it is one we found that is not plain; that one they read in the repository after claiming. You can change it while the posting is unclaimed. Once someone claims, it is frozen with the rest of the terms.

If we cannot read the repository to look, nothing is published and the draft stays. Try again in a moment; we never treat a failed read as "no command".

An acceptance command, for this task alone. Your assistant can also name a command that runs the tests for this one task, such as npm -w web test. Send it as acceptanceCommand to draft_posting, confirm_posting or edit_posting; the web form does not offer it, and it keeps what your draft named. It sits beside the repository's own test command and never replaces it, so you can name one even when we found a command. It follows the same rules as a test command you name. We record it with the posting and show it to developers before they claim. If the full command fails, we run it on its own, on a fresh copy of the submitted code, with a five-minute limit, and show its result under the verdict. You can change or clear it while the posting is unclaimed, and it is frozen once someone claims. A posting you review yourself can't carry one.

From an assistant, the same two values are testCommand and runtime on draft_posting, confirm_posting and edit_posting, and publish_requirements says in advance whether you will need them.

Developers see what the task needs before they claim. The same read records the runtime and its version, the install command, the test command, and any services the repository runs beside the app, such as a database. The posting page shows them under "What you'll need", with the commit they were read at. It also shows when the lockfile is behind the manifest, because then the install cannot use it.

Some things the repository does not say. The confirmation page asks for those, and every answer is optional:

  • the runtime version, when no file pins one;
  • the image for a service the repository names without one, whose tag, name parts and registry host labels follow the same short-plain-word rule as a test command, so postgres:16 is accepted and a tag like Tr0ub4dor3 is not (a secret written as a short plain word, in the tag or in a host label, would still be shown);
  • operating-system limits, which no file records, such as "Linux only".

A field you leave blank shows developers "unknown", never nothing. The page only asks what the repository leaves open. An answer to something it already settles is refused, and the repository's own value is what developers see. A runtime version you give is shown to developers; it does not choose the image a verification runs in.

From an assistant, the answers are runtimeVersion, os and serviceImages on draft_posting, confirm_posting and edit_posting. publish_requirements lists which are open. A draft is written before the repository is read, so when it is confirmed, any answer it carries that the repository settles is dropped rather than refused.

If a developer claims the task and cannot set it up, they can hand it back as setup-failed and name what failed. why_not_claimed counts those hand-backs per posting, and says which requirement failed once three or more developers have said so.

Drafting from an AI assistant

You do not have to start in the browser. Point any MCP client — Claude Desktop, Claude Code, Cursor, or a hosted service like Lovable — at https://terminalhire.com/api/founder/mcp and your assistant can draft a posting from whatever it already knows about the problem. Nothing to install. Field-by-field setup, including where to get the token, is under "a host that only accepts a URL" in the MCP page.

It will ask you which repository the task is in, if it does not already know. That is required, not a nicety: the confirmation page resolves the commit against it. The repository cannot be added there afterwards. An assistant that drafts without one gets a refusal telling it to ask you rather than guess — a guess would point a public posting at someone else's code.

A draft gives claimants the whole repository at one commit. Your assistant cannot ask for a narrower tier: a draft that names sparse or issue-only is refused, with a message telling it to leave the tier out. draft_posting writes a draft and hands back a link; you open the link, sign in, read the posting rendered, and confirm it. The link grants nothing on its own — opening it signed out asks you to sign in, and drafts expire after a day.

It can carry your reference links across. If you have already pasted a Loom recording or a Figma frame into the conversation, your assistant can attach it to the draft rather than leaving you to paste it again in the browser — and it is told to ask you whether you have anything of the kind, in case you did not know the option is there. The links are listed on the confirmation page before you confirm, so you see every link a developer will get. Same rules as links added under Context: six at most, https: only.

It can carry what you told it, too. Your assistant can send notes from the conversation with the draft (contextNotes, up to 4,000 characters): what you said, the steps to reproduce, what you expect. None of this is required. Your assistant is told to offer once, and to draft without notes, links or files if you say no or there are none.

Your assistant cannot send files. The confirmation page has a Context section after the request, the same one New task has. It lists the notes, the links and any files, or says No context added. Type a note or paste a link and press Add to context; a note joins the notes the draft came with, and an https link in it is added to the links. A link pasted on its own is saved as a link only, with no note, unless it would be a seventh link; then it is kept as a note. Edit changes the notes and Remove takes off the notes or a link. Each change is saved on the draft as you make it. Press Attach files to add screenshots, recordings and other files, up to eight of up to 100 MB each; each joins the draft once it has uploaded, and Remove takes it off. All of it is optional, and a draft with none confirms the same way. Post task saves a note you typed and did not add; if that note cannot be saved the task is not posted and the bar says so. It waits for a file that is still uploading and for a change that is still being saved, and for nothing else here. When the draft is posted, from the page or by your assistant, the notes and files go onto the task as one note under Context, which the developer who claims the task reads. If the task posts and that note cannot be written, the page you land on says so. Add context on the task takes new text and files; the files you added to the draft do not come across, so add them again there.

Notes and files need the draft to carry your project's record. A draft carries none when its repository is on none of your projects, or when it is drafted without the record on purpose (projectContext: null, or --no-project in the terminal). Then the notes are not kept and your assistant is told so, and the confirmation page takes no notes, links or files. A project with changes you have not confirmed refuses the draft: your assistant is told to confirm the record with you and draft again, and is not offered a draft without it.

It can also publish that draft, if you let it. A connector you created with permission to act can call confirm_posting, which publishes a draft using your repository and your saved card. Once the publishing requirements are met, an unacknowledged full draft returns an exposure notice with the repository and commit, and waits for acknowledgment. A sparse draft saved before that rule returns the selected files and waits for confirmed counts. Neither preview publishes the posting. For a full draft, the second call has to echo that notice back with a signed token we issued for that draft, repository and commit, which goes stale in half an hour; a sparse draft's second call echoes the counts instead. A read-only connector — the default, and every connector created before this existed — can draft and read but cannot publish, and it saves project answers as proposed for you to confirm.

The posting tools. Tools marked acts need a connector you gave permission to act. Project context tools are described in MCP.

Tool What it does
preview_work reads a public task preview without claiming
draft_posting writes a draft, publishes nothing
publish_requirements which of App, card, email is missing
list_own_postings your postings, never the claimant
pending_count how many wait on a decision from you
claim_progress per posting: attempts, latest check, claim id
claim_verification the newest verification run for a claim
get_claim_patch a held patch and why it was held
get_check_results the sandbox check run for the latest submission
why_not_claimed decline reasons, hidden under three answers
start_card_setup (acts) links to your dashboard to save a card; no charge
send_contact_confirmation (acts) first-time only: mails a link to confirm your email
confirm_posting (acts) publishes a draft you reviewed
edit_posting (acts) changes a published posting of yours
withdraw_posting (acts) takes an open posting down
request_changes (acts) asks the developer for another pass
approve_held_change (acts) approves a held change, if the project allows it
rerun_verification (acts) runs a claim's tests again at the same commit

list_own_postings, pending_count and claim_progress name no developer at all.

draft_posting, publish_requirements and edit_posting take decisionWindowHours (24 to 48, 48 if you leave it out) and lapseAccept (automatic acceptance: off if you leave it out, on when you pass true). edit_posting refuses to change either once the posting has a claim. See Your decision deadline.

Every tool but draft_posting and preview_work needs a connector token in the Authorization header — you create one per client in the dashboard, it is shown once, and it works until you revoke it. draft_posting works without one; hand it a token and the draft is attributed to you and the reply names any publishing requirement you are still missing.

No tool on that server moves money. Accepting finished work, releasing funds, refunds and settlements happen only in the browser, signed in as you. The one exception is a posting that accepts automatically: it is accepted and charged 24 hours after a missed decision deadline (see Your decision deadline). Publishing a posting binds your saved card to it so a claimant knows the task is funded; nothing is charged until the work is accepted.

A posting you confirm this way is recorded as agent-drafted and human-confirmed. It is your posting; the record just says how it was written.

Open or approval-only

An open posting can be claimed by any developer approved for paid tasks — that is an invite list while the beta runs, not a score or a history check — who has also set up payouts. Good for a public repo where a pull request is the whole interaction.

An approval-only posting shows up in the same places, but a developer registers interest and you decide. Nothing about your repo reaches them until you do.

If your repo is private, approval-only is forced — not as a default you can change, but on the server, whatever the form says. For a private repo, approving someone is granting them access, and that should never be something you did by leaving a checkbox alone.

If your team recorded the project, a posting that carries that record is also forced to approval-only, and you can't change it to open.

What developers see before you approve

A posting on the public index carries your title, your public summary, an opaque handle like poster/b-9f2c4e6a8b0d, the price, the tags, the effort estimate, and the claim mode.

It does not carry your repository, your name, your GitHub login, your email, the issue link, or your spec. That holds whether the repo is public or private, and whatever you choose below.

Your title publishes by default, on a private repo as much as a public one. That is new. It used to be held back, and the result was a listing that read Private-repo posting · typescript, react and told a developer nothing about the work — so nobody could decide whether to claim it without claiming it first. Hiding the title was never what kept your repo private; the fields in the paragraph above are.

If a particular title says more than you want a stranger to read, untick show this title on the open listing in the composer. That posting falls back to a stand-in built from your tags — Undisclosed paid task · rust, postgres — so a developer can still tell two of them apart. You can change your mind later, including while someone is working on it: the setting is on the edit form and it is not frozen by a live claim.

Decide it before you publish, not after. The tick box is on the confirmation page too, so a posting your agent drafted carries your answer from its first moment. The index is public and cached for a few minutes, and the terminal client keeps its own copy, so a title held back an hour after publishing was still read for that hour. Turning it off later stops the next reader, not the last one.

Your public summary publishes either way. That is the one thing the tick box does not touch. You write it in a box that says it publishes and you approve the exact characters, so it is the piece of prose that was always meant for strangers — which is why there is no version of it to hold back.

Once you approve someone, they get the title and the spec whatever this setting says. How much of the code they get is covered in the next section.

How much of a private repo you hand over

A new posting gives the developer the whole repository. The dashboard composer offers no other scope, and neither does a draft your assistant writes: a request for issue-only or sparse is refused, not widened. We retired those two because choosing files by matching words in the spec does not work on a large repository.

Full. The developer clones the repository through a read-only credential scoped to that one repo. The credential can read its history and every branch. You acknowledge that exposure before publishing.

Postings made before this keep their recorded scope, so two narrower scopes are still live on older postings:

Issue-only. You list the files yourself and can supply their contents. What we ask GitHub is about access and identity — whether our App still covers the repo, whether it is private, and which repository it is — and none of it opens a file. The developer gets the repro, the stack trace, and the confirmed file list with any contents you supplied, as a copy, with no access to the repository.

Sparse. With our App on that repo we read your tree to propose a slice; without it you paste the file list and we propose from that. Nothing is stored until you confirm the counts. We start from the files your issue text points at, then add whatever those files import, so a file arrives with the things it refers to rather than on its own. That widening follows imports wherever they lead: a slice can span several directories and pick up build config from the top of the repository, so read the counts rather than assuming a boundary. It is sent as a copy, still with no access to the repository.

For issue-only and sparse, the screen shows you what is being left out as well as what is going: "42 files, 1,180 excluded." Read that number. A list of included files looks equally reasonable whether it is tight or far too generous, and the excluded count is the only part of the screen that tells you which one you are looking at.

For issue-only and sparse, we scan the files before they go. A clear credential — a key, a token, a private key block, a .env — stops the hand-off outright and we send nothing. Two blurrier shapes go a different way: a password inside a connection string, and a bare assignment that reads like a secret. Most of those turn out to be fixtures, docs and templates, so we put them in front of you instead, and they travel only if you tick each one. That hard stop arrives while you are still scoping, before the posting exists, so a tripped scan never leaves you with a live posting that can't deliver code; the same scan runs again when you confirm, as the authoritative second check. Every file that arrives with content is scanned, even one outside the slice — if you sent its bytes, we looked at them. The same happens if the scan cannot finish: a scan that did not complete has not cleared anything, so we treat it as a refusal rather than a pass. You will see what tripped it and can narrow the slice or fix the file.

For full, there is no scan, and there cannot be one. The code travels from GitHub to the developer through a short-lived read credential and never passes through us, so there are no bytes on our side to check. We will not ship a scanner that gives the feeling of having looked when it has not. Instead you confirm, before the posting exists, that everything committed to that repository is exposed and that rotating it is yours to do. Read that literally: the credential is scoped to the repository rather than to the files we show you, so it reaches history as well — a secret committed once and deleted in a later commit is still in there. No confirmation, no full posting.

Every new posting therefore requires an exposure acknowledgment before publication. There is no file list to scope, so instead the form reads the commit your selected base branch is on right now (the repository default when you leave the branch blank) and shows it to you in full, followed by the exposure notice, with a box you have to tick before the posting can be created. If that commit cannot be read — usually because the App is not installed on the repository — the form says so and refuses to post. It will not fill in a placeholder: a notice naming a commit nobody identified is not something you can meaningfully agree to.

Connecting your GitHub App

Every posting needs the TerminalHire Poster GitHub App installed on its repository, public or private. You install it once, from the dashboard, and pick the repositories it can see — GitHub asks you, not us.

You can add repositories later in the App's settings on GitHub.

The App is how the code gets out and how the patch comes back. It reads contents and pull requests, and reads your Actions runs so we can show you whether the checks passed. It never holds a key of yours: access is a short-lived token we mint per posting and throw away.

Uninstall it whenever you like, from GitHub's settings. Postings that depended on it stop being able to deliver code, and say so on the row rather than failing quietly.

The work comes back as a patch

For a private repo the developer never pushes to your repository. They send a patch, and we apply it on a branch in your repo, on your behalf.

Choose Base branch when posting if your integration branch is dev or another existing branch. Leave it blank to use the repository default. An issue-only posting has no base branch: it grants no repository access, so a branch is refused. The claim keeps the branch and starting commit it received; later posting changes do not retarget it. The confirmation page shows the branch from the draft. Before publication, a new draft changes it, and you acknowledge that draft's exposure notice. Once published, the base branch is fixed and cannot be edited: edit_posting refuses the field, and to deliver to another branch you withdraw the posting and post it again.

After applying the patch, the App opens a pull request into that branch, or updates the existing open PR for the claim. The title is the posting's title, or a fixed title if you chose not to describe the posting publicly. Each body names the exact commit, changed files, requested verification and screenshot links, and adds your public summary of the task, the developer's own description of the work (or says none was sent) and how to check out and review the commit. Results and uploads may still be pending; the owner review page holds the recorded evidence, and it shows the same description. A new submission replaces the body and marks earlier evidence superseded. We never merge the PR for you.

If GitHub refuses the pull request with a permission error, most likely because the App lacks pull_requests: write, the work remains on its branch and the notification says so. Other PR failures also leave the branch available; the next submission retries PR delivery.

On a whole-repository posting they do hold a credential, and it is worth being plain about it: read-only, scoped to that one repo, and short-lived. It cannot write, which is why the patch is still the only way work comes back. On an older issue-only or sparse posting they are issued no repository credential at all — the files arrive as a copy.

What we check is what the patch does, not which files it names. A change to your CI config, your git internals, an install script, a script you already have or a new one that runs before or after another is refused, and so is a patch we cannot read. You see the refusal rather than a surprise commit. Content written so it cannot be read at a glance, such as a long encoded blob or an eval( call, is refused too. A binary file is applied and recorded with the change only when it is an image, a font or a PDF: its name must end in .png, .jpg, .jpeg, .gif, .webp, .pdf, .woff, .woff2, .ttf or .otf, and its contents must start the way a file of that type starts. Any other binary file is refused, programs included, and so are executable files and binary files over 2 MB (3 MB per patch). A package-lock.json (v2 or v3) or yarn.lock (v1) change is accepted with the package.json change it belongs to, when every new entry comes from the npm registry with its integrity hash. Other lockfiles are refused. A dependency change, a new script or a manifest change applies without asking you, and is recorded with the change. That is the default, and it stays on unless you turn that off — Dependency and manifest changes, on the posting page, covering every posting on that repository. With it off, each of those is refused. Code that reaches the network is applied and recorded on either setting.

No new change waits for your approval while a task is in progress. Your one decision is whether to accept the finished work.

Test changes

Changes to existing tests, including deletes and moves, are applied and recorded with the change. So is adding, changing, deleting or moving recognized test-runner configuration or setup. A check result on such a change comes from tests the change itself edited. We store that record with the change. The task page does not show it yet, so look at the pull request's changed files before you accept.

The recognized names are case-sensitive:

  • Existing tests under __tests__/, tests/, test/ and spec/; *.test.* and *.spec.*; Python test_*.py and *_test.py; Go *_test.go; bare test or tests with a .js, .cjs, .mjs, .ts, .cts, .mts, .jsx, .tsx, .py, .rb or .php extension; Ruby *_spec.rb; Java *Test.java; and C# *Tests.cs.
  • Any change under __mocks__/, __fixtures__/ or fixtures/, including new files.
  • Runner config and setup: vitest.config.*, vitest.workspace.*, vitest.projects.*, vitest.setup.*, jest.config.*, jest.setup.*, jest.preset.*, setupTests.*, playwright.config.*, cypress.config.*, karma.conf.*, ava.config.*, pytest.ini, conftest.py, tox.ini, noxfile.py, .coveragerc, .mocharc*, .nycrc*, .c8rc*, bunfig.toml, phpunit.xml* and .rspec. A new conftest.py is recorded too: it can alter collection or add fixtures that skip existing tests.
  • Shared config: the test value in vite.config.*; jest, vitest, mocha, ava, nyc, c8 and jasmine keys in an existing package.json; pytest, nose, coverage and tox sections in setup.cfg, including [tool:pytest], [pytest], [nosetests] and the coverage, tox and testenv section families; and pytest, coverage and tox settings under tool in pyproject.toml, including [tool.pytest.ini_options]. Unrelated settings remain ordinary changes when the checker can establish that the test settings are unchanged.

Before applying the patch, we also read recognized Vitest, Jest and Vite config from the base revision, before the patch's changes. Vitest's setupFiles and globalSetup, and Jest's setupFiles, setupFilesAfterEnv, globalSetup and globalTeardown, identify support files whose changes are recorded. Vitest include and Jest testMatch identify matching test files; edits, deletes and moves of those files are recorded too. We expand supported globs against the base tree, so a README outside the matches can still change. An extensionless setup path is resolved against .ts, .tsx, .mts, .js, .mjs, .cjs and .jsx; exactly one match identifies the support file. We follow local Vitest workspace/project files and directories to their configs, and local Jest presets to their setup settings. A package-name Jest preset does not by itself make the config unreadable; package internals are outside this check. These checks do not execute repository config.

Some configuration remains uncertain: an extensionless path with no match or several matches, a glob with no matches or unsupported syntax, a dynamic value, an unreadable local config, a cycle or a reference deeper than eight levels. Discovery still stops at 256 directories; file, config-read and glob-expansion budgets also bound the work. If configuration remains uncertain or a limit is reached, every change to that repository, even a README edit, is recorded as one whose test configuration we could not read. Imported or spread test values, shared-config parse failures, undecodable TOML keys and missing sources for declared deletes are recorded too.

An ordinary new test remains accepted. Detected focus or suite-wide skipping in a new test is recorded: examples include .only(, test.only, it.only, describe.only, fit( and fdescribe(; a root-level before or beforeAll that calls this.skip() or ctx.skip(); and module-level pytest.skip or pytestmark = pytest.mark.skip. Focus names match as whole words, so profit( does not count as fit(. A new file's describe.skip or bare pytest.mark.skip skips only its own tests, so those alone stay accepted. Ordinary non-test setup.cfg sections, such as metadata, remain accepted; the test-related sections listed above are still recorded.

This list has limits. A shared helper imported from outside the recognized folders and base-config paths, such as src/testUtils.ts, is not recorded just because a test imports it. Unusual runners and config locations outside this coverage can also pass. These checks cannot establish what only running the suite can reveal. Restoring check files and tracking an expected-test inventory are separate work under TERM-1136; they are not a guarantee provided by this record.

A patch is not held to the files you disclosed, so read the branch before you accept.

Your workflows may run on the branch push or the pull request before you review it. We read their configuration for potential secret exposure and record matching workflow names on the attempt, in the PR body and in your submission email. An incomplete scan says so. This warning does not hold delivery or change your workflows, and it does not prove whether a workflow ran. Excluding th/** from push triggers does not exclude a pull-request trigger into your base branch. Review both with the person who owns your CI. When the run finishes, the result lands on the posting row: passed, failed, or still going. That is the evidence you decide on — your tests, not our claim about them.

Two other readings sit beside it. get_check_results reports the sandbox check run for the latest submission — status, counts, a trimmed log tail. claim_verification reports the newest verification run for the claim, which is your suite executed in a fenced container with the network cut. Both are also on the claim's panel in the dashboard.

Deciding

Today, the first page of your dashboard, lists what is waiting on you, oldest first. Each row shows its price and, where the record says, how it would be charged. The band above the list shows the nearest decision deadline and your task credit. If we could not read finished work, claims, held changes, deadlines or credit, the page says which and gives no all-clear. If you also take work, open it at /dashboard?view=poster. If your account only posts work and you have a project, the dashboard opens that project's Home in place of Today: the project you last opened in this browser, or the one changed most recently. The task list stands beside Home and a task's pages; Questions, Context and New task are one column. The old address of your task list, /dashboard?tab=postings, opens that Home with All tasks chosen, and More no longer lists Today or Tasks once you have a project. Settings opens inside the same menu, with More and Settings marked. The bell beside your account lists what waits on you under Action required and the rest under Updates. Each row names the task and opens its page. A row for a task in another project names that project. Opening the bell marks nothing read; opening a row, or Mark all read, does.

The Tasks list sorts by what is waiting on you. A row marked needs you has a developer blocked on your answer, and the badge opens the panel that answers it.

A task has three views, Review, Run & evidence and Code & PR, with your decision beside all of them. Run & evidence shows a run as the result only for the exact commit on the page, and says so when a run covers another submission.

No new change is held for your approval: it goes to the task's branch, and you decide once, when the work is finished. The rest of this paragraph is about a change that was already held before that rule. It has no commit, run or pull request until you approve it, or until the developer sends a newer change, which replaces it. If the project team explained the change, the panel shows that explanation first, marked as the team's words and not a test result; it does not change what approving applies. If the developer sent a description, it sits above our findings, marked as their words: we did not check it. You approve the change or send it back from the decision column, one change at a time, and neither charges anything. After you approve, the page shows the commit it produced, and the run stays missing until one is recorded for that commit.

When work arrives you accept or reject it, with a rating from 1 to 5 and an optional note.

On a task published under the pilot no card is involved: accepting pays the full price from credit, or is refused. For any other paid task, save a card first under Settings → Payments. Saving the card and publishing a posting do not charge it; a saved card is not escrow and does not guarantee a later charge will succeed. The final button reads accept — pay $X. That explicit click charges the posted amount. Only after Stripe confirms the charge does TerminalHire record the public acceptance and reserve the developer's payout.

The developer receives 90% of the posted amount. TerminalHire retains 10% and absorbs Stripe's processing fee. If the card is declined or needs authentication, no acceptance or payout is recorded; replace the card or retry from the same decision panel. A retry on the same card after a decline can change the rating or note. If you replaced the card first, send the rating and note you used before. Most refusals name their cause in the panel, such as a price below the minimum. If your bank asks you to confirm the payment and you don't finish, you can still reject, ask for changes, withdraw, or release the developer's claim: we cancel the unfinished payment first. An unfinished payment is also cancelled automatically after 24 hours. Withdrawing before acceptance needs no refund, because nothing was charged — with one exception: a posting paid for up front, before this was how it worked, is refunded from the dashboard rather than withdrawn.

Rarely, a payment goes through but we can't record the accept automatically. Nothing is accepted or paid to the developer yet. A person on our team reviews it, and we email you, even if you have turned off our other emails.

An accept is public. A reject is not. An accepted decision becomes part of that developer's credential — the thing they can show someone else. A rejection is your private judgment of a person's work, and publishing it would turn claiming a posting into a bet on a stranger's mood. Rejections stay between you and them.

Notes are redacted after 180 days. The decision and the rating stay.

Your decision deadline

When a developer first submits work, you have your posting's decision window to accept, reject or ask for changes. The window is 48 hours unless you set a shorter one when you post, down to 24 hours. A claim keeps the window it was claimed under, and once a posting has a claim its window cannot change. The claim page shows poster decision due with the time, and the developer sees the same line on theirs. Asking for changes stops the clock while the developer works, and the line goes away. Their resubmission starts the window again. Accepting or rejecting ends the clock.

We email you twice before the deadline: halfway through the window, and again when an eighth of it is left. On the 48-hour default that is 24 hours and 6 hours before. The emails follow the same notification settings as the others. The deadline cannot be extended.

If the deadline passes, the claim reads not decided in time, and the developer sees that on their claim and in their notifications. Automatic acceptance is off unless you turn it on: tick Accept automatically after a missed deadline when you publish, or have your agent pass lapseAccept: true to draft_posting. A posting on a project with a live membership always publishes with it off. On a posting that accepts automatically, you then get 24 more hours to accept, reject or ask for changes. After that the work is accepted and your saved card is charged. New work submitted during those 24 hours starts your window again from that submission.

The automatic accept only charges a card. If you have account credit when it falls due, it stops instead: nothing is accepted or charged, and we email you so you can accept the work yourself, which spends the credit first. The publish page says whether any credit stops it, or only credit that covers the whole price.

On a posting that doesn't accept automatically, nothing else happens: no work is accepted, no card is charged and the claim stays open. You can still accept, reject or ask for changes afterwards.

How you hear about it

Seven things get you an email: a developer claims your posting, a patch arrives, your checks finish, a pull request opens, a submission is blocked, a developer asks to resolve the posting, and a developer leaves you a note. The last three share a test — you are the only person who can clear them, and there is no other way you would find out. A ninth notice goes out when a claim nobody started is released, and a tenth if your payment goes through but we can't record the accept automatically. Each email links straight to the row it is about; you sign in as normal, and the link grants nothing on its own.

We send to the contact email you confirmed. Publishing needs one, except under the pilot. With no confirmed address, we fall back to the public email on your GitHub profile, and with neither you get no email. Nothing else changes either way: the Tasks list is exactly current whenever you open it.

Reminders. If something is still waiting on you a day after we first emailed you about it, we may send a reminder, then another a day later and a third a day after that — never more than three, and none once you have acted. That covers four of the emails above: a developer waiting for your approval to start, a blocked submission, a developer handing a posting back, and a developer's note you have not answered (any later action of yours on the posting counts as answering). It also covers two setup steps you started and did not finish — saving a card, and confirming your contact email. That one goes to an address we already have for you, never to the address waiting to be confirmed. Finished work waiting on your decision is not on this list: its decision deadline, above, is how that wait ends.

Turning them off. Three ways, and only the last needs you to sign in:

  • Your mail client's own Unsubscribe button stops all of them except the held-payment email. On a reminder it stops reminders only, and the email says so.
  • Each of the seven carries two links: stop all these emails, and stop only this kind. The release notice is the exception — it has no per-kind switch, so only stop all and the settings page reach it. The held-payment email is not optional: it goes out even if you have stopped all emails, because it is about money we have already taken. A reminder carries one link, stop these reminders; stopping all posting emails stops reminders too.
  • Settings → Notifications (headed "posting notifications" on a developer account's dashboard), where each kind is its own switch, reminders included — and the only place you can turn them back on.

Most people want to keep "A developer starts your task". That is the one where someone is waiting on you.

Turning email off never hides anything. The Tasks list and the MCP count always show every event as it happens.

You can also read the same state without opening the dashboard: the poster MCP server's pending_count tool reports how many postings are waiting on you, and reports counts only. claim_progress goes one step further — how many attempts have been made on each posting and what your own checks said about the latest one. It also returns the id of the claim each posting is waiting on, so your editor can open that claim's checks and patch without asking you for a link.

Neither names the developer. That is a rule, not an oversight: the output of an MCP tool goes to whichever model your editor runs, and a developer working on your posting never agreed to that. Both tools are read-only. One tool replies: request_changes sends the developer a note asking for another pass, and only from a connector you created with permission to act. It records no decision and leaves the claim open. Accepting work and paying happen on the dashboard, signed in, and no tool does either.

No new change is held. A change that was already held waits for you to approve it on the task page, or for the developer's next change to replace it. If you turn on Agent may approve in a project's Overview, approve_held_change can approve one from a connector you gave permission to act. It is off until you turn it on, only you can change it, and only in the browser. The tool takes the patchSha256 that get_claim_patch showed, and refuses if the developer has replaced the patch since. It reads the setting when it is called and again just before it applies the change, so turning the setting off stops it. A task that is not on a project cannot be approved by an agent; approve it on the task page. Approving puts the change on the claim's branch, as your own click does, and the task page says your agent approved it. It is not accepting the work, and it charges nothing.

If a claim's latest run did not pass, or we could not complete it, rerun_verification runs the tests again at the same commit, with the same permission to act. The earlier result stays on record and the new run appears beside it; nothing is relabelled. The developer on the claim cannot ask for this, and a run that passed is not run again. In Claude Code, the plugin's /approvals skill walks these tools for you.

Why nobody is taking it

An unclaimed posting used to tell you nothing, and nothing is the one answer you can't act on. It can't tell "the price is too low" apart from "there's no CI in that repo, so I couldn't check my own work" — and only the first is fixed by paying more.

Developers looking at your posting in the CLI can now say why they're passing, picking one of five fixed answers. The why_not_claimed MCP tool reports what came back: how many passed on each posting, and the breakdown of their reasons.

It is counts, like everything else here. No developer is named, we store no login against an answer, and the breakdown on a posting stays hidden until at least three people have answered — below that you see the number who passed but not what they said, because one answer in a small group can point at a person. A posting with no declines and no claims is its own answer: nobody is getting far enough to have an opinion.

The posting's own page

Every posting has one, and the title on the Tasks list is the way in. The list is a queue — what needs you, what it costs, what state it is in — and the page is where you go to remember what a posting was about and to act on it.

It holds the task you wrote, everyone who claimed it, the whole history in one stream with each line attributed, the money, and your own rating on the entry it belongs to. The actions live there too: approving a developer, deciding on their work, editing the terms, withdrawing.

Editing. Until someone claims it you can change anything. After that the terms are frozen and you can still raise the price — a developer agreed to what was written, so changing it under them is not something we let you do. Every edit is recorded, and the page shows the history.

Two people waiting. If two developers are claiming one posting, both decisions are on the page, each next to the person it is about. The tab can only show you one.

Saying something to a developer

There is a box on the posting's page. Two buttons, because they mean different things: send note leaves a comment and changes nothing, and ask for changes marks their claim as needing another pass.

Either one is emailed to your developer with your words in it, and so is an answer to a question they asked. The email goes out only when we have an address for them and they have not turned that kind of email off. A note is not emailed to a developer who has been released from the claim. Nothing is pushed to their browser. Their CLI also shows a count the next time it syncs, and they run terminalhire claim notes to read it and the task's Context, or ask their agent to. So a reply may take a while, and silence is not being ignored.

A developer can write to you too, from their terminal. Their note appears on the posting's page, and you are emailed that it arrived. The email carries the note's words, each line marked with > between a --- begin --- line and an --- end --- line, so you can tell their words from ours. A note sent as a question is emailed without its text; you read and answer it on the page. Each developer can send at most 3 notes per claim and 10 to you in any 24 hours. If a note looks wrong — a pasted secret, text that reads as if a repository wrote it — use Report this note under it. The report is recorded, and we try to email it to our operators; if that email does not go through, reporting the same note again sends it. A report hides nothing and changes nothing on the developer's side by itself.

A developer can mark a note as a question. Your project's Home opens on Waiting on you, and each unanswered question has its own row there under Questions, naming the task it belongs to. A plain note adds no row. Open the row: every open question from that developer on that task is on the page, oldest first, each with its own reply box. A reply takes text, a file, a screen recording or a voice note. Questions in the project menu lists every open question on the project the same way, each under its task's name, then the ones you answered, newest first. Sending an answer clears the question it was written under and no other; the page then says how many are left. send note on the posting page clears none. Choose the developer's name followed by decides to hand a question back to them: it sends "You decide." as your answer. An answer cannot be edited after it is sent; send the developer a message to correct it. Delivered work on the same task has a row of its own under Awaiting your decision. The task's History keeps each question and your answer, with their dates.

Home's figures are filters. Awaiting your decision, In progress, Unassigned, Drafts and Paid each list their own tasks, and each total is the sum of the prices on the rows it lists. Drafts and Paid show only when they have tasks, and an amount only when one of them has a price. The figure you choose is framed and named beside the two tabs; choose it again, its name there, or a tab to clear it. Not yet paid adds the first three. A task is charged at acceptance.

The tabs are Waiting on you and All tasks. Waiting on you and the badge on Home count what you can act on now: a task under Awaiting your decision and each unanswered question. A task nobody has held for three days, or whose developer has sent nothing for three days, is under All tasks in its own state. Its row leads with how long it has waited, and on whom when a developer is working, and a task in progress says the same on its own page. It does not count in the badge.

Home opens on Waiting on you. When nothing waits on you it opens on All tasks. A tab or figure you choose is kept in the page's address, so a reload, Back and a copied link open the list on it, and it stays chosen as you move between Home and a task. Changing project starts again. Waiting on you is kept by a reload and by Back, but when you come back to Home through the menu with nothing waiting it opens on All tasks.

On a wide window, choosing a tab or figure beside a task it does not list opens the first task it does list. A tab with no task leaves the open task where it is.

To write to a developer first, choose Ask on the task page or on Questions. The button names the developer when one is working, and asks you to pick one when several are. It is offered while a developer is working on a task, and it takes text only. A message you send shows on that task's page at once, under Questions, with the developer's notes and the answered questions, newest first. Questions lists what you sent under Your messages, apart from your answers, and each row opens its task at that message.

The task page shows the request as a document: the price, repository, developer and posting date, then each section under its own heading. While no developer has taken the task, choose Edit beside a section to change that section alone, or Change beside the price. Sections can be edited one at a time when the request was written under those headings; otherwise use Edit request. Outcome must still say enough to publish, or the change is not saved. Change opens a panel with the price, a step of $5 either way, and what is charged: nothing now, the new price once, at acceptance. Once a developer is working the sections are locked, and the page says who is working. The price can still go up: Raise opens the same panel, which takes no lower amount. Raise is not shown while the page asks for your decision, approval or payment. The panel asks you to confirm a price ten times the current one. An unassigned task posted today says "Posted today" under its title, and its Posted fact reads "Today". History appears once something besides the posting has happened. When the developer has sent work, Changes, below the request, names the repository, and the pull request with a link to GitHub and how many files changed where each is recorded.

A task no developer has taken says so. If developers passed on it, the page shows how many gave each reason once three have answered, beside the change that answers it: Change price for a low price, and, when the request was written in sections, Edit scope for an unclear request and Edit acceptance when there is no way to check the work.

When a developer marks a note they had already sent, you are emailed that a question is waiting, unless you turned off emails about developer notes. A question still unanswered a day later gets one reminder email, sent between 09:00 and 20:00 New York time, unless you turned reminders off. That reminder is separate from the ones under Reminders above: another action on the posting does not stop it. Answering the question does, and so does the claim ending.

Reading how the work went

Open a claim and you get the whole run of it: every attempt the developer made, the short commit for each one, what your checks said, and the notes you sent back, in order. Where you used to see only the latest attempt and a count of the rest, you now see what happened in each.

The developer sees the same sequence from their side, including the notes you write when you send feedback or reject something. Write them as if they will be read, because they will be.

Your 1–5 rating shows on your own timeline, on the decision it was part of. It is never averaged and never shown as a figure of its own — a score lifted away from the work it was about is the first step toward a number that follows a person around.

Each attempt is also kept in your repository under refs/th/attempts/, so the code of an earlier try survives the next submission. These are not branches and not tags: they will not show up in your branch or tag lists, and they cannot trigger a workflow. They are there so the history stays inspectable.

Taking a posting down

Withdraw removes a posting from the index. You will find it on the row in the Tasks list, and it asks once before doing it.

A live claim no longer blocks it. Closing a posting ends every open claim on it and tells each developer why, rather than leaving them working on something that has gone. Three cases still refuse. A developer has submitted work you have not decided yet — decide that one first, accept or reject with a reason. The work was already accepted, which leaves nothing to withdraw. Or the posting was paid for up front, which goes through a refund instead: that takes it down and returns the money.

A withdrawn posting stops appearing to developers within a few minutes.

There is no delete. Withdraw hides it from developers; the record stays, because decisions attached to it are part of somebody's credential.

A patch is accepted only from the person whose claim it is. They record the claim against their signed-in GitHub account, work in a clone of your repository, and submit from their terminal; it lands on a branch in your repo with their commit authorship. On an approval-only posting nothing is delivered and no patch is accepted until you approve the claimant from the needs you panel.

Explore the work and its project

The Work area has views for Working on, Posted by me, and Find work. Developer accounts keep the dark workspace across these views; poster-only accounts use the light workspace. A task opens with its next action, readable task description, progress, and activity.

Open Projects to explore a project's saved goals, workflow, constraints, sources, and open questions before or after it has a repository. Context lists proposed and disputed answers on its Proposals tab and unresolved ones on Overview, each with a button to accept, edit or answer it. Tasks keep the confirmed project context attached when they were prepared; later project edits do not change an existing task's scope. The project's Tasks tab lists the tasks you have posted from it, with each one's status and who moves it next. A task posted without the project's context attached is listed there only when your team drafted it for this project.

Manage editor and agent connectors in Settings → Agent connections.

Share one project

Open Projects, choose your project, and use People you’ve invited to invite someone by their GitHub login. Check the profile before choosing Viewer or Collaborator and creating an invitation. Copy its link and send it to that person. The link lasts seven days; they must sign in with the GitHub account you invited and accept it. Their project then appears under Shared with you on Projects.

Both roles can read the project record, delivery policy, repository names, people, proposals, notes, questions, and task titles and statuses. The services map and service proposals show kinds, names, providers, purposes and environments. Credit, billing, prices, submitted branches, service addresses, administrators and private service notes stay hidden. Repository access still comes from GitHub separately.

A collaborator can add a note, ask a question or propose an answer or delivery field. Their contributions carry a collaborator label. A proposal changes nothing until it enters the record; the owner confirms the record, or on a member project the team records it, and the owner publishes tasks, accepts work and controls payments and App access. A viewer has no editing controls.

Both roles see proposed values in place, labelled as waiting on the owner, and the same review sections under Discussion, without Accept or Dispute. The page says how many proposals wait on the owner. Nothing is needed from a viewer or collaborator for them.

The owner can remove a pending invitation or active person from People you’ve invited. To change a role, remove the person and invite them again with the new role. Removal ends access on the next request and keeps their contributions in the project. Expired or removed invitations need a new link from the owner. The owner removes an expired invitation first, because a person can hold only one live invitation on a project. If the acceptance page names a different account, sign out and use the invited account. An account that has been erased cannot be invited again through this flow.

Shared project navigation

Owners, collaborators and viewers use the same project menu: Home and Context, with Activity and People under More. The owner also has Questions and New task. Open a task from Home to see the information your role can access. Shared access includes task titles and status; developer submissions, owner review controls and payment details remain private. Owners open their task or claim review from the task link. Collaborators can add notes, questions and proposals under Context; viewers can read the discussion.

New task opens a draft in the same pages. It has two places.

The Request is what you want done, and it is what a developer reads before claiming. It has a field each for Outcome, Scope, Deliverable and Acceptance. What you type in a field is that section and stays there; nothing is moved for you, and a heading you paste into a field stays in it as text. Outcome is required, at least 5 words or 25 characters; Scope, Deliverable and Acceptance are optional. Type the Title yourself, and set the price with Set price in the strip above the fields. The request can be up to 6,000 characters.

Context, after the request, is supporting material and is optional. Type a note or paste a link and press Add to context, or press Attach files, paste or drop a file, or record your screen or voice. Whatever you add is listed under the Context heading at once: pictures as pictures, files by name, each note and each link on its own line, each with Remove, and a note with Edit. With nothing added it says No context added. Nothing you add to Context becomes part of the request. Any https link in a note is also added to the task's links, up to six. A link pasted on its own is saved as a link only, with no note, unless it would be a seventh link; then it is kept as a note. For a file kept elsewhere, such as a Google Drive file or a Loom recording, paste its link. TerminalHire does not open a link or check who can see it, so make sure the developer can open it. A task takes up to eight files of up to 100 MB each (photos, video, audio, PDFs and text), and up to 4,000 characters of notes. A file joins the draft by itself once it has uploaded.

Post task, with the price once it is set, stays at the bottom of the window, with "Charged at acceptance" beside it. It stays off until the draft has a title and an Outcome, and the line beside it names what is left. Nothing in Context holds it back: a note you typed and did not add is added when you post, and the button waits only for a file that is still uploading. When you post, your notes and files go onto the task as a note and show under Context on its page, after the request, where Add context adds more. If the task posts but its context could not be added, the page says so and offers Try again. Options, under Context, holds the project and repository, reference links, the base branch, whether you approve each developer before they start, and the repository notice you read and tick before posting. After you post, you land on the task's own page.

Review work with your project

Open a project to see its menu in the sidebar, or along the bottom on a phone. More holds Activity and People, a link to all your projects, Settings and the other pages of TerminalHire. The project control at the top of the sidebar switches between your projects. Work groups tasks by what happens next. Use Review next task or a task's review button to open the submission. The project navigation stays in place while you read.

Your account menu is at the foot of the sidebar, or at the top right on a phone. Work also shows the project owner and current members with their roles. Pending invitations appear separately. Open Manage people as the owner, or View people as a collaborator or viewer, for the full people view.

Owners, collaborators and viewers use the same workspace. Collaborators can add feedback and project notes; viewers can read them. Only the owner can approve permission, request changes or accept paid work. Billing stays private.

When work is delivered, the owner's page for the task shows the developer's summary, a preview where the developer gave one, the check result, and one GitHub line with the repository, the pull request and the files changed. Request changes and Accept & pay stay at the bottom of the window. Accept & pay opens a confirm step, and nothing is charged until you press Confirm. Accepting changes nothing on GitHub: merging the pull request is your team's to do.

Show feedback with photos, video, an audio recording or a file. A change request stays attached to the version reviewed, with its message and attachments. It does not replace the original task description. A note or file the owner adds to a task is shown to the developer who holds that task, on their claim page. On a task where you approve each developer before they start, the developer sees those notes and files only after you approve their claim; until then their claim page reads Available after approval. A collaborator's note stays inside the project. Project Context also accepts notes and attachments.

When a proposed change needs permission, the developer first explains what it does, where it comes from, why it is needed, what it affects and its access or impact. The owner reviews that explanation before allowing the change. Allowing it does not accept the finished work or release payment.