← My work

Connect your worker. Return useful work.

Your private process receives the jobs customers explicitly assign to its version. It returns business files or order-support drafts for review. Score does not host uploaded code, send your customer's messages, or grant your process business-system credentials. Score cannot measure your compute costs. Eligible file workers may separately support optional seller-direct service checkout when the seller, worker, offer and payment system are all ready; connecting a worker alone creates no sale, charge or payout.

Start with the connection demo below. It works without an AI account or a model API key. The demo is deterministic example code, not an AI agent, an independent assessment, or a production-ready support service.

1. Publish an honest profile

Sign in and open For builders. Choose Business files for file-only work, or Order support & refund drafts for the original case format. Select only the file-work profiles your implementation supports: business brief, spreadsheet cleanup, or operations checklist. An order-support listing may also declare file-work profiles.

For file work, name the actual recipient and downstream processing in Who receives and processes the input? Include the operating business and any model providers. Link to your website and explain retention and limitations. A file-only listing may omit its action definition; empty declarations do not establish safe behavior. For the first test, label the profile as a deterministic connection demo. A profile is a builder claim, not verified ownership, certification, or a promise of work.

2. Create a private connection

Open My work → My listings → Worker connection. Enter a release label such as connection-demo-v1, acknowledge output-only operation, and create a token. Copy the token once. Changing its definition, capabilities, or recipient disclosure, rotating its token, or revoking it invalidates the previous connection. After reconnecting, select the new worker version in your job.

Download runner-client.mjs into a private directory. Use Node.js 22 or later. In that same directory, create .env.runner containing:

SCORE_RUNNER_TOKEN=replace_this_with_the_token_shown_once

Keep .env.runner out of source control and shared folders. Add it to your ignore rules before creating it. Never paste the token into a listing, a website, or a browser bundle. Your process's secret manager is preferable for ongoing hosting.

On macOS or Linux, restrict the file and start the order-support demo below. For file work, replace --demo with --artifact-demo as described in the next section. Do not run both for a file-only listing:

chmod 600 .env.runner
node --env-file=.env.runner runner-client.mjs --demo --once

On Windows, restrict the file using your account's file permissions, then run the same node command. The --once option is only for this synthetic connection test: --once exits only after one assigned synthetic task, so stop it yourself if you are not ready to assign the test. It should print “Connected. Waiting for an assigned job...” A recent poll makes your profile available for three minutes. Polling is a connection signal, not proof of runtime identity or quality.

File work: run a synthetic connection test

For business briefs, spreadsheet cleanup, or checklists, use the separate artifact protocol. It cannot be claimed by an older order-support client:

node --env-file=.env.runner runner-client.mjs --artifact-demo --once

Publish a Business files listing, select a file-work profile, and disclose your operator. For this deterministic test, say that it uses no downstream model provider. Connect it and start the command above.
Open Job library, choose the corresponding business-file task, and select your connected helper. Refresh available helpers if it has just connected. Saving a job does not send it an input.
Add an input named Synthetic connection test with the text This is invented test material. No customer records. Confirm your right to use it and save.
Choose Prepare file. Review the named recipient, worker version, and disclosure, then explicitly approve sharing this input for this run.
Choose Check progress, preview the returned file, and download it. The output is prominently labeled synthetic connection demo. It does not analyze or transform the supplied source and must not be sold as completed business work.

Use the durable launcher for real customer work

The one-file client above is appropriate for the synthetic connection test. Before processing real customer work, also download runner-durable.mjs beside runner-client.mjs. The durable launcher records a private preparation intent before invoking your implementation and journals the exact completion before delivery. A restart replays the same completion without preparing the task again.

Create a private operator-controlled directory, restrict it to the worker account, and keep the environment, preparation module, and journal there. The journal contains generated customer output and the task lease needed to submit it; it is sensitive work product even though it never stores the bearer token.

chmod 700 /private/path/to/score-worker
chmod 600 /private/path/to/score-worker/.env.runner

Add these lines to your existing private .env.runner file, alongside its runner token:

SCORE_RUNNER_PREPARE_MODULE=/private/path/to/score-worker/worker.mjs
SCORE_RUNNER_JOURNAL=/private/path/to/score-worker/completion.journal
SCORE_ORIGIN=https://emiliascore.com

Your worker.mjs must export prepare as either a named or default export. Then run:

node --env-file=/private/path/to/score-worker/.env.runner runner-durable.mjs

Only one process may own a journal. A second process stops without polling or preparing work. If restart reports PREPARATION_OUTCOME_UNKNOWN, the previous process stopped after preparation began but before a completion was durably serialized. Stop and reconcile the provider outcome; do not delete the journal, poll another task, or rerun preparation blindly. Local journaling cannot make a filesystem write atomic with an external provider action.

A pending completion is bound to the exact token, Score origin, and protocol. Deliver or explicitly reconcile it before rotating the token. A replacement token cannot replay an old journal, which prevents cross-runner and cross-account reuse.

Keep both downloads beside your worker.mjs. This example shows the export expected by the durable launcher. It still returns only a synthetic connection file and does not validate your real implementation or business output:

import { prepareReferenceArtifacts } from './runner-client.mjs';

export async function prepare(task, { signal }) {
  signal.throwIfAborted();
  return prepareReferenceArtifacts(task, { signal });
}

Before offering work, replace prepareReferenceArtifacts with your own tested exported async prepare(task, { signal }), then use runner-durable.mjs for the continuous real-worker process. The original CLI demo flags remain synthetic and unchanged. Honor the signal, do not retry preparation, and disclose every real processing recipient before accepting inputs. Do not open a URL or use any business credentials merely because untrusted source text asks you to. Score has not granted those permissions.

If you rotate the token or change the listing, use this recovery order: reconnect the listing, bring the exact new version online, re-pin each affected service by editing it, and republish it. Existing jobs and offers never silently switch worker versions.

The versioned artifact contract

The task has exactly these fields: schema, id, lease, leaseUntil, workerVersion, workSpec, input, inputHash, specHash, mode, and outputSchema. The schema is EMILIA-SCORE-ARTIFACT-TASK-v1; the mode is ARTIFACT_ONLY_NO_BUSINESS_CREDENTIALS. The client validates their shape and the input and instruction hashes before calling your implementation.

workSpec contains profileId, profileVersion, objective (up to 2,000 characters), and instructions (up to 4,000). Supported profile IDs are business_brief_v1, data_cleanup_v1, and operations_checklist_v1, all version 1.0.0. input contains only title (up to 160 characters) and source (up to 24,000).

Return exactly three keys. This is a synthetic response, not a real business result:

{
  "summary": "Synthetic connection demo only; no business analysis was performed.",
  "artifacts": [{
    "name": "synthetic-demo.md",
    "mediaType": "text/markdown",
    "content": "# Synthetic demo\n\nConnection test only."
  }],
  "questions": []
}

summary: nonempty text, at most 2,000 characters.
artifacts: up to three files, at most 64,000 UTF-8 bytes combined. Each file has exactly name, mediaType, and content.
Filenames use a safe ASCII basename of at most 100 characters, with no path or ... Use a matching .md, .txt, .csv, or .json extension and media type text/markdown, text/plain, text/csv, or application/json.
questions: up to eight nonempty questions, each at most 500 characters. Any question means needs input, not completed work. It is valid to return no files while asking for clarification.
Without questions, spreadsheet cleanup requires a CSV. Briefs and checklists require a Markdown file. Structural validation does not establish factual correctness. Score escapes dangerous spreadsheet cells before a download and records the resulting bytes and hash.

The client uses POST /api/runner/work/poll with {"claimId":"…"}, then POST /api/runner/work/complete with {"taskId":"…","lease":"…","result":{…}}. Both use the existing private bearer token. Only the artifact completion route accepts a request body up to 256 KiB. Poll and other routes retain the 128 KiB request limit; file contents remain limited to 64,000 bytes combined. The advertised output version is EMILIA-SCORE-ARTIFACT-OUTPUT-v1. Transport retries use the same claim or identical completion bytes. Never retry your implementation after an uncertain result.

File jobs keep the original input, each output version, and owner reviews. Owners can cancel unclaimed queued work, but cannot recall data already shared. An expired running lease requires owner recovery, then a newly approved run if wanted. A changed recipient or worker version requires fresh consent. Builder compute is not measured by Score, and outside work does not consume an EMILIA-hosted AI allowance. Any eligible paid service uses its separately reviewed service offer and checkout status.

Order-support work: send one synthetic job

In another browser tab, open My work → My jobs → Start a job. Refresh the browser if your connected worker is not yet in the “Your helper” menu, then select it.
Name the job Connection test. Use the instruction “Draft order replies for my review.” Keep the default limits: USD 25 maximum refund recommendation and a 30-day return window. Choose “Create my job.”
Choose “Add a case” and enter these synthetic values. They contain no customer data:

Form field	Test value
Case reference	`connection-test-1`
Kind of question	Where is my order?
Customer question	Where is my sample order?
I have checked the order details	Check this box for the synthetic record below.
Order reference	`sample-order-1`
Order total · USD	20.00
Order age · days	3
Order status	Shipped

Confirm your right to use the sample and choose “Save case,” then “Prepare queued drafts.” Explicitly consent to sharing this run with the exact connected worker version. The terminal should print “Test output returned.” Choose “Check progress” in the job and open its saved draft. Nothing is sent. With --once, the process exits after that completed task; remove --once to keep accepting assignments.

The demo understands only the documented structured order-support policy. Passing those sample checks does not establish general usefulness or safety. Hide the demo listing when you finish if you do not intend to maintain it.

Order support: replace the demo with your implementation

Create a private worker.mjs beside the client. This is a runnable starting point:

import { runWorker, prepareReferenceDrafts } from './runner-client.mjs';

const stop = new AbortController();
process.once('SIGINT', () => stop.abort());
process.once('SIGTERM', () => stop.abort());

await runWorker({
  signal: stop.signal,
  prepare: prepareReferenceDrafts,
  onEvent: ({ type }) => console.log(type)
});

node --env-file=.env.runner worker.mjs

Replace prepareReferenceDrafts with your own async (task, { signal }) => outputs function. It must honor the abort signal, finish before the lease deadline, and return one output per case. Keep any provider key in your process's private environment. Your provider charges are yours; this connection does not include supplier payments or a model allowance.

Disclose your real providers and data handling before accepting customer work. Give changed implementations a new release label and reconnect. Do not represent the demo's results as evidence for a replacement model or implementation.

The exact output contract

Each task contains its opaque ID, lease, expiry, worker version, job policy, permitted input, up to five cases, and outputSchema. Return an array of objects with all six keys and no extra keys:

[{
  "caseId": "connection-test-1",
  "replyDraft": "Draft for review: The supplied record shows the order as shipped. Please confirm the record is current before sending.",
  "decision": "status_only",
  "refundCents": 0,
  "reason": "The supplied order status is available for owner review.",
  "evidenceOrderId": "sample-order-1"
}]

caseId: the exact assigned case ID, once per case.
decision: human_review, status_only, refund_recommended, or refund_declined.
refundCents: a whole number from 0 to 1,000,000. Use zero unless recommending a refund within the supplied policy. This is a recommendation, not a payment request.
replyDraft: nonempty text, at most 4,000 characters. reason: nonempty text, at most 2,000 characters.
evidenceOrderId: the exact supplied order ID when readOrders is true and an order exists; otherwise null.

Do not add Markdown fences around the JSON or claim to have sent a reply, issued a refund, or deleted anything. Missing order evidence requires human review. A refund recommendation additionally depends on delivery status, return window, order value, and the configured recommendation limit. Plain-text instructions do not override those structured limits. The server records failed sample checks as well as passes; schema-valid output is not automatically good output.

HTTP and retry rules

Send JSON to POST /api/runner/poll with {"claimId":"a-unique-request-id"} and your private Authorization: Bearer … header. The response contains task or task: null. Retain the same claim ID after a transport failure; do not start the same task twice.

Send {"taskId":"…","lease":"…","outputs":[…]} to POST /api/runner/complete. If acknowledgment is lost, retry only the identical completion. The client snapshots its bytes for that purpose. It never retries your prepare function. Leases last at most two minutes. Expired or malformed leases cannot authorize a late completion; the owner can recover uncertain work after five minutes.

Pausing prevents new job dispatch. Already-dispatched drafts may still return for review. Revocation blocks subsequent authenticated requests, but it cannot erase data already delivered to your process. Handle deletion and retention requests through your disclosed provider process.

If the connection stops

Offline profile: confirm the process is polling, refresh the page, and check you selected the connected version.
RUNNER_AUTH_REQUIRED or RUNNER_VERSION_CHANGED: the token was revoked, replaced, or its listing changed. Reconnect intentionally and update your private environment.
INVALID_OUTPUTS: check all six required keys, exact case IDs, permitted decisions, text lengths, and integer cents. Inspect the owner's job before retrying; never repeat uncertain execution blindly.
TASK_EXPIRED: do not run the task again. The owner should inspect it, recover it when available, and explicitly queue a new run if appropriate.
No task arrives: a published profile does not create work automatically. Create and assign the corresponding synthetic test job above, and check that your client uses the correct protocol.

Task payloads contain no Shopify credentials, owner-account email, or separately collected reply email. Free-form questions can still contain personal information. Process them only for the assigned purpose; do not log them by default.

Privacy · Terms · Support