@usefactory/factory-darwin-arm64 0.3.0-dev0 → 0.3.0-dev1

package/EULA.md

@@ -0,0 +1,203 @@
+# Factory — End User Licence Agreement
+
+**Version 1.0 · 29 August 2026**
+
+This Agreement governs your use of **Factory**, the command-line software distributed as
+`@usefactory/factory` and its platform packages ("the Software"). By installing, activating or using
+the Software you agree to it. If you do not agree, do not install it, and remove any copy you have.
+
+The Software is licensed, not sold.
+
+---
+
+## 1. What you may do
+
+Subject to your compliance with this Agreement, you are granted a non-exclusive, non-transferable,
+revocable licence to:
+
+1. **Install and run the Software** on the number of machines your plan allows, for the purpose of
+   building, maintaining and operating software — your own, your employer's, or your clients'.
+2. **Keep everything the Software produces.** All source code, documentation, configuration,
+   diagrams, test suites and other output generated by a Factory run are **yours**. No licence,
+   claim, royalty or attribution is asserted over your work product. This applies to commercial work
+   without restriction.
+3. **Use the Software on private and proprietary codebases.** Nothing in this Agreement requires you
+   to disclose, open-source or share your code.
+
+Your plan's limits — how many agents may run in parallel, how many machines one key activates, which
+optional capabilities are enabled — are recorded in the signed licence your installation holds and
+are described at `factory upgrade`.
+
+## 2. What you may not do
+
+You may not:
+
+1. **Redistribute the Software**, in whole or in part, to anyone else — including by publishing,
+   mirroring, bundling, reselling, renting, leasing, sublicensing, or making it available as a
+   hosted or managed service.
+2. **Reverse engineer, decompile, disassemble, decrypt, or otherwise attempt to derive** the
+   Software's source form, prompts, agent definitions, orchestration logic, or the contents of its
+   sealed payload, except to the minimum extent that applicable law expressly permits and cannot be
+   contracted out of.
+3. **Extract, copy, reproduce or republish the Software's prompts, agent definitions, skills,
+   policies or orchestration logic**, whether obtained from the sealed payload, from a running
+   process, from memory, from a temporary filesystem, or by asking a model to reproduce them.
+4. **Circumvent, disable, patch, forge or tamper with licensing or entitlement enforcement**,
+   including the signed licence, the pinned issuer key, the seal on the payload, the activation
+   process, or any limit your plan imposes. This includes using a licence you were not issued and
+   using a modified build of the Software.
+5. **Share your activation key** with anyone outside your organisation, or use one key to serve more
+   machines or people than your plan permits.
+6. **Remove or obscure** copyright, licence, or attribution notices.
+7. **Use the Software to build a competing product** by using it as a reference for, or a source of,
+   agent prompts or orchestration logic.
+
+Sections 2.1 through 2.4 are material terms. A breach of any of them terminates this licence
+immediately under section 9.
+
+## 3. Your Claude subscription, and Anthropic's terms
+
+**Factory runs on your own installation of Claude and your own Anthropic credentials.** It never
+handles, stores, transmits, proxies or has access to any Claude or Anthropic credential; it drives
+the Claude installation already authenticated on your machine, and all model usage is billed to you
+by Anthropic under your agreement with them.
+
+You are responsible for:
+
+1. Holding a valid Claude subscription or API access, and complying with **Anthropic's own terms of
+   service and usage policies**, which govern your model usage and are not superseded by this
+   Agreement.
+2. Any charges Anthropic bills you for usage that Factory initiates on your behalf.
+
+**We are not affiliated with, endorsed by, or sponsored by Anthropic.** "Claude" is a trademark of
+Anthropic. If Anthropic changes its terms, its products, or its enforcement in a way that restricts
+or prevents this pattern of use, that is outside our control, and section 7 applies. Your remedy is
+to cancel under section 8.
+
+## 4. Fees, renewal and cancellation
+
+1. **Paid plans are billed monthly in advance** through our payment processor. Prices are shown at
+   `factory upgrade` and at the point of purchase. The free plan is free.
+2. **Subscriptions renew automatically** each period until cancelled.
+3. **You may cancel at any time**, through `factory upgrade --manage`. Cancellation takes effect at
+   the end of the period you have already paid for. **We do not refund partial periods.**
+4. **When a paid subscription ends** — by cancellation, by non-payment, or by expiry — your
+   installation continues to work on the **free plan**. It is not disabled, your work is not locked,
+   and nothing you have produced becomes inaccessible. Only the paid plan's limits go away.
+5. **A licence is valid until it expires.** Licences are short-dated and renew silently while you
+   use the Software; a cancellation therefore takes effect at the next expiry rather than
+   immediately.
+6. We may change prices with **30 days' notice** for existing subscribers, effective at your next
+   renewal after the notice period.
+7. Fees exclude taxes. You are responsible for any sales tax, VAT, GST or withholding that applies
+   to you.
+
+## 5. Activation, and what leaves your machine
+
+To license a machine, the Software sends **an email address, an activation key, and an opaque machine
+identifier** (a hash — never a hardware serial, never a hostname in plain form) to the activation
+service, and receives a signed licence in return. That is the whole of it.
+
+The Software does **not** transmit, and the activation service does not receive:
+
+- your source code, your prompts, your requests, or anything a Factory run produces;
+- any Claude or Anthropic credential;
+- telemetry, analytics, usage metering, or a record of what you built.
+
+**A licensed installation does not need the network.** Once activated, licences verify offline
+against a key inside the binary; a valid licence authorises a run with no network call at all, and
+an expired one has a grace period beyond that. The two commands that do require the network are
+`factory activate` and `factory upgrade`, and neither runs during a build.
+
+Email addresses and activation records are held for the purpose of operating your licence and are not
+sold, rented, or shared for marketing.
+
+## 6. Ownership
+
+The Software, and every part of it — including its prompts, agent definitions, skills, orchestration
+logic, accumulated learned-rule store, and the design of all of the above — is owned by the licensor
+and protected by copyright and other laws. This Agreement grants you a licence to **use** it and
+transfers no ownership. All rights not expressly granted are reserved.
+
+**Your work product is not part of the Software.** See section 1.2.
+
+## 7. No warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND
+NON-INFRINGEMENT.
+
+Two disclaimers deserve to be said plainly rather than only in capitals:
+
+1. **The Software directs a large language model to write and modify code, run commands, and change
+   files in your repository.** Its output is not guaranteed to be correct, secure, complete, or
+   suitable for any purpose. **Review everything it produces before you rely on it, and use version
+   control.** You are responsible for what you ship.
+2. **The Software depends on third-party software and services** — Claude, Anthropic's APIs, and the
+   packages it installs — whose availability, behaviour, pricing and terms are outside our control
+   and may change or stop without notice.
+
+## 8. Limitation of liability
+
+TO THE MAXIMUM EXTENT PERMITTED BY LAW, THE LICENSOR IS NOT LIABLE FOR ANY INDIRECT, INCIDENTAL,
+SPECIAL, CONSEQUENTIAL, EXEMPLARY OR PUNITIVE DAMAGES, OR FOR ANY LOSS OF PROFITS, REVENUE, DATA,
+GOODWILL, OR BUSINESS INTERRUPTION, ARISING OUT OF OR RELATING TO THIS AGREEMENT OR THE SOFTWARE,
+WHETHER IN CONTRACT, TORT, OR ANY OTHER THEORY, AND WHETHER OR NOT ADVISED OF THE POSSIBILITY.
+
+THE LICENSOR'S TOTAL AGGREGATE LIABILITY UNDER THIS AGREEMENT IS LIMITED TO **THE GREATER OF (a) THE
+AMOUNT YOU PAID FOR THE SOFTWARE IN THE TWELVE MONTHS BEFORE THE CLAIM AROSE, AND (b) USD 50.**
+
+Nothing in this Agreement excludes or limits liability that cannot lawfully be excluded or limited,
+including liability for death or personal injury caused by negligence, or for fraud.
+
+Some jurisdictions do not allow certain exclusions or limitations. In those jurisdictions the
+exclusions and limitations above apply to the fullest extent permitted, and the rest of this
+Agreement remains in force.
+
+## 9. Term and termination
+
+1. This Agreement runs until terminated.
+2. **You may terminate** at any time by cancelling your subscription and removing all copies of the
+   Software.
+3. **We may terminate immediately** if you materially breach this Agreement — in particular any of
+   sections 2.1 to 2.4 — with no refund.
+4. **We may suspend or terminate an account** used to redistribute the Software, to circumvent
+   licensing, or to abuse the activation or billing services.
+5. On termination, the licence in section 1 ends and you must stop using the Software and destroy all
+   copies. Sections 2, 6, 7, 8, 10 and 11 survive termination.
+6. **Your work product survives termination unconditionally.** Nothing here requires you to delete,
+   stop using, stop distributing, or stop selling anything the Software produced for you.
+
+## 10. Changes to this Agreement
+
+We may update this Agreement for future versions of the Software. Material changes will be noted in
+the release notes and in this file's version line. **The version of this Agreement that ships with
+the copy of the Software you installed is the one that governs your use of that copy.** Continuing to
+use a later version after an update means you accept the Agreement that ships with it.
+
+## 11. General
+
+1. **Governing law.** This Agreement is governed by the laws of the licensor's principal place of
+   business, without regard to conflict-of-laws rules. The courts there have exclusive jurisdiction,
+   except that either party may seek injunctive relief anywhere to protect intellectual property.
+2. **Entire agreement.** This is the entire agreement between us about the Software, and supersedes
+   any prior understanding, including any statement in the README, the documentation, or marketing
+   material. Where they differ, this document governs.
+3. **Severability.** If any provision is held unenforceable, it is modified to the minimum extent
+   needed to be enforceable, or severed, and the rest stands.
+4. **No waiver.** A failure to enforce a provision is not a waiver of it.
+5. **Assignment.** You may not assign this Agreement without written consent. We may assign it in
+   connection with a merger, acquisition, or sale of assets.
+6. **Third-party components.** The Software installs and depends on third-party packages, each under
+   its own licence. Those licences govern those components; nothing here limits any right you have
+   under them.
+7. **Export.** You must not use or export the Software in violation of applicable export control or
+   sanctions law.
+
+---
+
+**Questions about this Agreement, or about a licence:** open an issue or contact the address in the
+package's README.
+
+`factory doctor` prints the exact version of the Software and the licence installed on a machine, and
+is the fastest way to answer "which terms apply to this install".

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usefactory/factory-darwin-arm64",
-  "version": "0.3.0-dev0",
+  "version": "0.3.0-dev1",
   "description": "The darwin-arm64 build of Factory. Installed automatically by @usefactory/factory; not useful on its own.",
   "license": "UNLICENSED",
   "os": [

package/sidecar/src/main.mjs

@@ -26,6 +26,15 @@ const rpc = new Rpc(process.stdin, process.stdout);
 let activeAbort = null;
 let aborting = false;
 
+// The live Query handle.
+//
+// `query()` returns an async generator that ALSO carries the control requests — getContextUsage,
+// supportedModels, setModel. The first version of this file consumed the generator in a `for await`
+// and never kept the handle, so none of them could be reached and the CLI had no way to ask the
+// session anything about itself. Keeping it is the whole of the change; the loop is unaffected.
+/** @type {any} */
+let activeQuery = null;
+
 function log(level, message) {
   rpc.notify('log', { level, message: String(message) });
 }
@@ -168,7 +177,8 @@ rpc.handle('run', async (spec) => {
   const summary = { ok: false, sessionId: null, result: null, error: null, aborted: false };
 
   try {
-    for await (const msg of query({ prompt: spec.prompt, options })) {
+    activeQuery = query({ prompt: spec.prompt, options });
+    for await (const msg of activeQuery) {
       if (msg.type === 'system' && msg.subtype === 'init') summary.sessionId = msg.session_id ?? null;
       if (msg.type === 'result') summary.result = msg;
       // Forwarded raw. Go filters; a lossy projection here would have to be revisited by every
@@ -181,6 +191,7 @@ rpc.handle('run', async (spec) => {
     summary.error = String(err?.message ?? err);
   } finally {
     activeAbort = null;
+    activeQuery = null;
   }
   if (aborting) {
     summary.ok = false;
@@ -189,6 +200,113 @@ rpc.handle('run', async (spec) => {
   return summary;
 });
 
+/**
+ * What the session knows about itself: context window occupancy and the plan's rate-limit windows.
+ *
+ * BOTH CALLS ARE OPTIONAL AND BOTH ARE ALLOWED TO FAIL. The usage one is marked EXPERIMENTAL in the
+ * SDK's own types — "may change or be removed in any release without notice", and the method name
+ * is promised to change when it stabilizes — so it is reached by feature detection rather than by
+ * name at the call site, and a failure returns nulls instead of raising. An indicator that stops
+ * appearing is a cosmetic regression; a run that dies because a status bar could not be drawn is
+ * not acceptable.
+ *
+ * Measured before this was written: with a plain string prompt (not streaming input), both calls
+ * succeed against a real session.
+ */
+rpc.handle('metrics', async () => {
+  const q = activeQuery;
+  const out = { context: null, limits: null, subscription: null, available: false };
+  if (!q) return out;
+
+  try {
+    if (typeof q.getContextUsage === 'function') {
+      const c = await q.getContextUsage();
+      if (c) {
+        out.context = {
+          percentage: c.percentage ?? null,
+          totalTokens: c.totalTokens ?? null,
+          maxTokens: c.maxTokens ?? null,
+          model: c.model ?? null,
+        };
+      }
+    }
+  } catch (err) {
+    log('debug', `context usage unavailable: ${err?.message ?? err}`);
+  }
+
+  try {
+    // Found by prefix, not by its full name: the SDK promises the name will change when the API
+    // stabilizes, and a hardcoded call site would then silently stop reporting.
+    //
+    // getOwnPropertyNames, NOT Object.keys. Class methods live on the prototype and are
+    // NON-ENUMERABLE, so Object.keys returns none of them — the first version of this found
+    // nothing, every sample came back with the context filled in and the limits null, and the bar
+    // silently showed half of what it was built to show. The direct check comes first so the
+    // common case does not depend on reflection at all.
+    let key = null;
+    if (typeof q.usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET === 'function') {
+      key = 'usage_EXPERIMENTAL_MAY_CHANGE_DO_NOT_RELY_ON_THIS_API_YET';
+    } else {
+      const names = new Set();
+      for (let o = q; o && o !== Object.prototype; o = Object.getPrototypeOf(o)) {
+        for (const n of Object.getOwnPropertyNames(o)) names.add(n);
+      }
+      key = [...names].find((k) => k === 'usage' || k.startsWith('usage_EXPERIMENTAL')) ?? null;
+    }
+    if (key && typeof q[key] === 'function') {
+      const u = await q[key]();
+      out.subscription = u?.subscription_type ?? null;
+      out.available = u?.rate_limits_available === true;
+      out.limits = u?.rate_limits ?? null;
+    }
+  } catch (err) {
+    log('debug', `rate limits unavailable: ${err?.message ?? err}`);
+  }
+  return out;
+});
+
+/**
+ * The models this Claude Code offers, for the switcher. Returns [] rather than failing.
+ */
+rpc.handle('models', async () => {
+  const q = activeQuery;
+  if (!q || typeof q.supportedModels !== 'function') return { models: [] };
+  try {
+    const list = await q.supportedModels();
+    return {
+      models: (list ?? []).map((m) => ({
+        value: m.value,
+        displayName: m.displayName ?? m.value,
+        description: m.description ?? '',
+      })),
+    };
+  } catch (err) {
+    log('debug', `model list unavailable: ${err?.message ?? err}`);
+    return { models: [] };
+  }
+});
+
+/**
+ * Switch the model for what the session does NEXT.
+ *
+ * The factory is one long query in which the orchestrator dispatches subagents, so there is no
+ * session boundary to wait for — but there is still no way to change the model of a turn already in
+ * flight. The SDK's own wording is "the model used for subsequent responses", and that is exactly
+ * what the CLI tells the user.
+ */
+rpc.handle('setModel', async (params) => {
+  const q = activeQuery;
+  if (!q || typeof q.setModel !== 'function') {
+    return { ok: false, error: 'no live session' };
+  }
+  try {
+    await q.setModel(params?.model || undefined);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: String(err?.message ?? err) };
+  }
+});
+
 rpc.handle('cancel', async (params) => {
   abortRun(params?.reason ?? 'cancelled by the CLI');
   return { cancelled: true };