software-defence-factory 0.11.0 → 0.11.1

package/.agents/skills/README.md

@@ -1,6 +1,6 @@
 # Factory skills
 
-These six original, portable skills are project-local Markdown. They require no AIOS installation. A harness must discover `.agents/skills` or receive the selected SKILL.md explicitly. The export command `node scripts/export-kit.mjs NEW_OUTPUT_DIRECTORY` stages these skills with the portable adoption kit. Copy the needed folders into a target repository under its own accepted instructions before dispatch. Do not overwrite its AGENTS.md.
+These six original, portable skills are project-local Markdown. A harness must discover `.agents/skills` or receive the selected SKILL.md explicitly. The export command `node scripts/export-kit.mjs NEW_OUTPUT_DIRECTORY` stages these skills with the portable adoption kit. Copy the needed folders into a target repository under its own accepted instructions before dispatch. Do not overwrite its AGENTS.md.
 
 - [factory-triage](factory-triage/SKILL.md): Turn an incoming factory issue into a bounded disposition and capability request. Use before specification or implementation starts.
 - [factory-spec](factory-spec/SKILL.md): Write an implementable factory task with observable acceptance criteria, required capabilities and a bounded verification plan.

package/README.md

@@ -1,27 +1,35 @@
-# Software & Defence Factory
+# Factory
 
 A portable method and a local runtime for taking a scoped software task through implementation, checks, independent review and an explicit handoff.
 
-Developed by [Arcitai](https://github.com/arcitai). The CLI is **software-defence-factory**. It works with existing repositories, Codex, Pi or a configured executor. No personal context system is required.
+Published by [Arcitai](https://github.com/arcitai). Invoke **factory** with your existing repositories, Codex, Pi or a configured executor. The npm package remains **software-defence-factory**; the compatibility executable `software-defence-factory` uses the same implementation, state and updater.
 
 ## Start here
 
 Install the published [npm package](https://www.npmjs.com/package/software-defence-factory). The CLI includes the dashboard; no source checkout is needed.
 
 ```sh
-npm install --global software-defence-factory
-software-defence-factory help
+npm install --global software-defence-factory@latest
+factory help
 ```
 
-For occasional use: `npx software-defence-factory@latest help`.
+For occasional use: `npm exec --package=software-defence-factory@latest -- factory help`.
+
+Starting with 0.11.1, the package provides both executable names. To upgrade an
+older global installation, run
+`npm install --global software-defence-factory@latest` to expose the new `factory`
+executable. Private cached updates keep the old command working but do not add
+global symlinks. Check `command -v factory` first; if it belongs to another tool,
+keep the compatibility command or use the explicit `npm exec` invocation above.
+Do not overwrite it with `--force`. See [installation compatibility](docs/npm.md).
 
 Choose the part you need:
 
 | Outcome | Command / guide |
 | --- | --- |
 | Set up an operator, worker and application | [Setup plan and acceptance checklist](docs/setup.md) |
-| Use the method with your existing agent | `software-defence-factory kit --output ./factory-kit` — exports a new staging directory |
-| Try the runtime without inference | `software-defence-factory demo` — Docker required; synthetic sample only |
+| Use the method with your existing agent | `factory kit --output ./factory-kit` — exports a new staging directory |
+| Try the runtime without inference | `factory demo` — Docker required; synthetic sample only |
 | Connect an existing repository | [Runtime quickstart](docs/quickstart.md) |
 | Understand installation and updates | [npm and npx](docs/npm.md) |
 | Restore a dashboard after boot or reconnect remotely | [Services and SSH tunnels](docs/services.md) |
@@ -41,7 +49,7 @@ The project dashboard has an **Inbox**, measured **Analytics**, **Agents**, **Sk
 
 The optional **defence** workflow accepts scoped incident evidence and produces a private, read-only draft. It does not monitor production or claim verified recovery. See [defence integration](docs/defence-integration.md).
 
-Start setup with `software-defence-factory foundation` and the [Factory Foundation plan](docs/setup.md). No AIOS installation is required.
+Start setup with `factory foundation` and the [Factory Foundation plan](docs/setup.md).
 
 ## Repository map
 
@@ -55,8 +63,6 @@ Start setup with `software-defence-factory foundation` and the [Factory Foundati
 | `scripts/`, `tests/` | Packaging, qualification, release checks and behavioral tests |
 | `docs/` | Setup, architecture, recovery, proof and ownership |
 
-The current runtime replaces earlier prototypes. Their source and research remain in Git history; they are not part of the installed package.
-
 ## Contributing
 
 Requires Node 22.13+, npm and Git. Docker is needed only for integration qualification.

package/bin/software-defence-factory.mjs

@@ -304,7 +304,10 @@ try {
   } else if(command==='kit') {
     if(!flags.output)throw new Error('kit requires --output NEW_DIRECTORY');
     await stream(process.execPath,[join(ROOT,'scripts/export-kit.mjs'),resolve(flags.output)]);
-  } else if(['help','--help','-h'].includes(command))console.log(`Software & Defence Factory ${VERSION} (test release)
+  } else if(['help','--help','-h'].includes(command))console.log(`Factory ${VERSION} (test release)
+
+Usage: factory <command> [options]
+Compatibility executable: software-defence-factory (same runtime and state)
 
   kit --output NEW_DIRECTORY               Export the portable method without a runtime
   demo                                    Install and run a synthetic sample (no model key)

package/docs/defence-integration.md

@@ -3,7 +3,7 @@
 The optional defence workflow receives a bounded incident record through:
 
 ```sh
-software-defence-factory incident --file /private/path/incident.json --state /private/state/my-app
+factory incident --file /private/path/incident.json --state /private/state/my-app
 ```
 
 Use factory/examples/incident.json as the input schema example. Intake validates scope and evidence, records a digest and deduplicates the event identity. Evidence and reports remain in the private installation. Do not place customer findings in public issues or source control.

package/docs/npm.md

@@ -4,24 +4,53 @@ Requires Node 22.13 or later. The method export needs no Docker. Running jobs
 also requires Git and a running Docker Engine or Docker Desktop on Linux/macOS.
 
 ```sh
-npm install --global software-defence-factory
-software-defence-factory help
+npm install --global software-defence-factory@latest
+factory help
 ```
 
 For a one-off invocation:
 
 ```sh
-npx software-defence-factory@latest help
+npm exec --package=software-defence-factory@latest -- factory help
 ```
 
 Both commands use the same package. A development checkout is unnecessary.
-Use `software-defence-factory kit --output /new/staging/directory` to export the portable
+Use `factory kit --output /new/staging/directory` to export the portable
 method. It refuses an existing destination and does not modify an app. Use
-`software-defence-factory init --repo /path/to/app --harness codex --check "npm ci && npm test"`
+`factory init --repo /path/to/app --harness codex --check "npm ci && npm test"`
 only when configuring the optional local job runner. `init` does not start jobs,
 copy skills into the app, or copy account credentials. Runtime jobs receive the
 bundled policy and skills directly. Model access is configured separately.
 
+## Executable and package compatibility
+
+Starting with 0.11.1, `factory` and `software-defence-factory` are bin aliases
+for `bin/software-defence-factory.mjs`. They share one runtime, state and updater.
+The npm package is still `software-defence-factory`, published by Arcitai from
+`arcitai/software-and-defence-factory`. Release qualification is tracked in
+[#61](https://github.com/arcitai/software-and-defence-factory/issues/61) and its linked delivery PRs.
+
+An older global bootstrap upgraded through the private release cache keeps
+working through `software-defence-factory`, including offline cached dispatch.
+It does **not** gain a global `factory` symlink. To expose both bins with
+0.11.1 or later, stop and reconcile installations, check `command -v factory`, then run
+`npm install --global software-defence-factory@latest`.
+If that name belongs to another tool, keep the compatibility executable or use
+`npm exec --package=software-defence-factory@latest -- factory ...`. Do not use
+`--force` to replace another program. npm refuses a conflicting unrelated bin.
+Both bin keys point to the same file; tarball tests cover explicit executable
+selection through npm exec and npx. The syntax above avoids relying
+on package-name inference. Never use `npx factory` or `npm install factory` for
+this product.
+
+The selected successor package is `factory-sd`, but account/OIDC prerequisites
+and namespace cutover remain pending under [#61](https://github.com/arcitai/software-and-defence-factory/issues/61).
+The issue records `factory` as owned by another project and `factory-sd` as a
+registry 404 on 2026-09-26; availability is not a reservation. Before cutover,
+verify replacement publishing trust, package/updater identity, Actions references,
+redirects and an explicit idle/recoverable upgrade route. Reconcile ambiguous
+external-write receipts without replaying them under a renamed repository.
+
 ## Persistent data
 
 The npm CLI stores private runtime data under
@@ -34,7 +63,9 @@ the npx cache, or your application repository.
 Source checkouts retain their existing `.factory/platform` and
 `.factory/demo-platform` defaults. Stop the old controller before moving an
 existing state directory. Update its `factory.json` repository path if necessary;
-start a fresh state directory for the native 0.3 runtime. Earlier engine journals are not automatically migrated; keep them separately as evidence.
+retain existing jobs, configuration and evidence. Branding requires no state move
+or migration. State/service/tunnel names, configured image IDs, update keys and
+historical policy/record hashes remain unchanged.
 
 ## Automatic updates
 
@@ -50,10 +81,10 @@ and restores their prior running set without interrupting a job. See
 [services](services.md) for installation, maintenance recovery and limitations.
 
 ```sh
-software-defence-factory update --check
-software-defence-factory update
-software-defence-factory update --auto off
-software-defence-factory update --auto on
+factory update --check
+factory update
+factory update --auto off
+factory update --auto on
 ```
 
 Updates use npm with lifecycle scripts disabled and retain immutable releases
@@ -73,8 +104,8 @@ installation or retained attempt needs them.
 
 ## Protected evidence compatibility
 
-0.10.0 recognizes version-1 execution profiles emitted by native **0.8.0,
-0.9.0, 0.9.1 and 0.10.0**. This is an exact allowlist in
+Factory 0.11.1 recognizes version-1 execution profiles emitted by native
+**0.8.0, 0.9.0, 0.9.1, 0.10.0, 0.11.0 and 0.11.1**. This is an exact allowlist in
 `factory/execution-profile.mjs`, independent of the installed package version;
 it is not a semver range or an automatic promise for later releases. Unknown
 runtime strings, unknown profile formats and incomplete legacy acceptance
@@ -101,9 +132,9 @@ neither a reason to discard evidence nor proof of compatibility. Retain
 unsupported records unchanged and obtain fresh applicable evidence through the
 normal workflow; never repair them by editing private records or hashes.
 
-The 0.10.0 writer retains the same profile format and original-base, aggregate
-single-parent candidate/check/review/approval guarantees. Continuation adds
-separate provenance; it is not acceptance evidence. The audited 0.8.0, 0.9.0 and
+Versions 0.11.0 and 0.11.1 use the same protected evidence writer and profile
+format, with original-base, aggregate single-parent candidate/check/review/approval
+guarantees. Continuation adds separate provenance; it is not acceptance evidence. The audited 0.8.0, 0.9.0 and
 0.9.1 writers remain supported only when their old records meet all current
 checks. For continuation specifically, the current completed review, successful
 Build/Verify, protected per-attempt artifacts, current policy and clean candidate
@@ -112,14 +143,10 @@ a checkpoint usable. Browser-disabled 0.8.0 records cannot satisfy a newly
 enabled browser policy. Missing or unsupported records stay unchanged and
 unavailable; no schema migration, profile relabeling or policy repair occurs.
 
-#71 shipped 0.9.0 through PR #81 and #84 shipped 0.9.1 through PR #85; both
-passed installed qualification, as reported by the lead. For this 0.10.0 slice,
-native Verify/Review remain required. The lead owns installed continuation,
-disposable protected PR/CI and desktop/narrow light/dark browser qualification
-on Z13. Controlled source fixtures do not supply that proof. New publication
-still requires the current remote target to equal the original accepted base;
-reviewed-candidate continuation preserves that baseline, while target refresh
-remains #72.
+New publication still requires the current remote target to equal the original
+accepted base; reviewed-candidate continuation preserves that baseline, while
+target refresh remains #72. See [the verification map](https://github.com/arcitai/software-and-defence-factory/blob/main/docs/proof.md) for delivered
+capabilities and the distinction between source checks and installed proof.
 
 ## Release flow
 
@@ -133,20 +160,27 @@ For a release, update both manifests with `npm version patch --no-git-tag-versio
 review the change, and push through the project's normal review flow. A code
 push without a version bump is tested but does not overwrite a published package.
 
-The first release is published by the maintainer. Then configure npm trusted
-publishing for GitHub owner `arcitai`, repository `software-and-defence-factory`,
-workflow filename `ci.yml`, with direct publishing enabled. Subsequent releases
-use short-lived OIDC authentication; no npm write token belongs in the repo or
-Z13. The source repository remains private, so npm cannot issue public source
-provenance for it. The public npm package contains an explicit runtime/method
+The current trusted-publisher identity is npm package `software-defence-factory`,
+GitHub owner `arcitai`, repository `software-and-defence-factory`,
+workflow filename `ci.yml`. The workflow uses short-lived OIDC authentication.
+The source repository is **public**, but the current workflow explicitly sets
+`NPM_CONFIG_PROVENANCE=false`; OIDC authenticates publication and does not mean
+this release emits npm provenance. No npm write token belongs in the repository
+or agent jobs. The public npm package contains an explicit runtime/method
 allowlist, excluding operational state, account data and retired research. It includes the explicitly labelled synthetic runtime fixture used by demo and qualification.
 
-Set the GitHub repository variable `NPM_PUBLISH_ENABLED=true` only after that
-first publication and trusted-publisher binding are complete. Until then CI
-still builds and tests every change, while publishing is deliberately skipped.
+Publication requires repository variable `NPM_PUBLISH_ENABLED=true` and the
+matching npm account binding. Preserve the working identity until replacement
+trust is verified. Changes must pass the normal protected PR/CI flow; do not
+weaken protection or bypass merge checks.
 After a CLI update, restart a stopped dashboard with `up --state PATH` and refresh
 the browser to load the new bundled interface. Updates do not replace the code
 of a controller that is still running.
 
+The installed native publisher refuses `.github/workflows` changes. Keep that
+guard. Automated GitHub Releases, immutable tags, registry readback and recovery
+after npm succeeds but Release creation fails remain a separate maintainer
+delivery under [#61](https://github.com/arcitai/software-and-defence-factory/issues/61).
+
 References: [npm/npx](https://docs.npmjs.com/cli/v11/commands/npx/),
 [npm trusted publishing](https://docs.npmjs.com/trusted-publishers/).

package/docs/ownership.md

@@ -1,9 +1,9 @@
 # Ownership and provenance
 
-Software & Defence Factory is developed by Arcitai. Original CLI, native Node/SQLite runtime, container boundary, incident intake, updater, method and six skills are maintained in this repository under MIT.
+Factory is developed by Arcitai. Original CLI, native Node/SQLite runtime, container boundary, incident intake, updater, method and six skills are maintained in this repository under MIT.
 
 The dashboard retains the selected third-party interface and interaction model, with modified branding and a factory-owned API integration. Its original copyright, source revision and permission notice are retained in [THIRD_PARTY_NOTICES.md](../THIRD_PARTY_NOTICES.md), together with notices for bundled UI components and fonts. Those notices are required source attribution, not runtime dependencies or product branding.
 
-The installed package includes no personal AIOS home, private owner memory or external agent plugin. A skill is an instruction, not a bundled browser, model subscription, provider account or security scanner. Codex/Pi are separately licensed tools included by the pinned Docker build; the operator supplies authorized inference access.
+A skill is an instruction, not a bundled browser, model subscription, provider account or security scanner. Codex/Pi are separately licensed tools included by the pinned Docker build; the operator supplies authorized inference access.
 
-Earlier research and prototype implementations remain in Git history. Their historical evaluation claims do not establish qualification of the current runtime. Current evidence is recorded in [proof](proof.md).
+Current verification boundaries are recorded in [proof](https://github.com/arcitai/software-and-defence-factory/blob/main/docs/proof.md).

package/docs/quickstart.md

@@ -2,18 +2,18 @@
 
 For a new execution host or remote operator, start with the [setup plan](setup.md).
 
-Install Node 22.13+, Git and Docker Engine/Desktop. Use an unprivileged account with Docker access. Install `software-defence-factory` through npm, or invoke the same package with npx. No factory source checkout is required.
+Install Node 22.13+, Git and Docker Engine/Desktop. Use an unprivileged account with Docker access. Install `software-defence-factory` through npm, or use `npm exec --package=software-defence-factory@latest -- factory help`. No factory source checkout is required.
 
 ## Qualify a synthetic installation
 
 ```sh
-software-defence-factory demo
+factory demo
 ```
 
 Open the printed localhost URL, inspect the sample task and its files, then approve the handoff. This changes only an isolated synthetic repository and makes no inference calls. Once the sample finishes:
 
 ```sh
-software-defence-factory qualify --state /absolute/path/printed/by/demo
+factory qualify --state /absolute/path/printed/by/demo
 ```
 
 The qualification intentionally creates failed, cancelled and interrupted tasks. They are expected evidence of failure handling. Never point qualification at an application installation.
@@ -23,9 +23,9 @@ The qualification intentionally creates failed, cancelled and interrupted tasks.
 Commit an intentional, reviewed starting point in the application first. Jobs clone committed code only; uncommitted work stays in the source checkout.
 
 ```sh
-software-defence-factory init --repo /absolute/path/to/app --harness codex --check "npm ci && npm test" --source-ref main --state /private/state/my-app --port 7331
-software-defence-factory install --state /private/state/my-app
-software-defence-factory doctor --state /private/state/my-app
+factory init --repo /absolute/path/to/app --harness codex --check "npm ci && npm test" --source-ref main --state /private/state/my-app --port 7331
+factory install --state /private/state/my-app
+factory doctor --state /private/state/my-app
 ```
 
 `init --source-ref` selects the configured default ref (`HEAD` when omitted). Each job resolves that ref, or an explicit `--source-ref` on `run`/`issue start`, in the configured repository and durably retains its commit before acknowledging admission. It records the canonical GitHub origin identity when available; the CLI and dashboard show the requested ref and resolved SHA. Task text and reference links do not select a repository, source ref or PR target.
@@ -71,8 +71,8 @@ container. Host loopback addresses do not automatically refer to the host from
 Docker. The package does not automatically expose Ollama or import models.
 
 ```sh
-software-defence-factory up --state /private/state/my-app
-software-defence-factory run --file task.md --source-ref main --state /private/state/my-app
+factory up --state /private/state/my-app
+factory run --file task.md --source-ref main --state /private/state/my-app
 ```
 
 A task should describe the accepted outcome, allowed scope and observable checks. The CLI also accepts `--issue https://github.com/owner/repo/issues/123` for an issue belonging to the configured origin; it uses the operator's existing gh access outside the job. The dashboard supports the same task workflow. Source text and links do not grant additional authority.
@@ -90,7 +90,7 @@ canonical GitHub origin and an explicit target while initializing the private
 installation:
 
 ```sh
-software-defence-factory init --repo /absolute/path/to/app --harness codex \
+factory init --repo /absolute/path/to/app --harness codex \
   --check "npm ci && npm test" --source-ref main \
   --delivery-provider github \
   --delivery-repository https://github.com/OWNER/REPO \
@@ -109,7 +109,7 @@ After the ordinary check, independent review and operator approval complete,
 use **Publish accepted candidate as draft PR** in task details or run:
 
 ```sh
-software-defence-factory publish JOB_ID --state /private/state/my-app
+factory publish JOB_ID --state /private/state/my-app
 ```
 
 Trusted publication requires protected per-run execution records for native
@@ -179,8 +179,8 @@ Build a compatible application image on the execution host, then select its exis
 local tag through the CLI:
 
 ```sh
-software-defence-factory install --image LOCAL_IMAGE_REF --state /private/state/my-app
-software-defence-factory doctor --state /private/state/my-app
+factory install --image LOCAL_IMAGE_REF --state /private/state/my-app
+factory doctor --state /private/state/my-app
 ```
 
 Selection resolves and retains the immutable image ID. It does not pull or build
@@ -228,5 +228,5 @@ is unnecessary for this CLI. Optional
 process settings are `SDF_AUTO_UPDATE=0` (skip automatic CLI update checks),
 `XDG_STATE_HOME`, `XDG_DATA_HOME` and `XDG_CONFIG_HOME` (user-owned state, release
 and service locations). They must be exported in the process environment.
-Legacy prototype names such as `FACTORY_WORKER_CONFIG`, `FACTORY_MODEL`, `PORT`
+Unsupported environment variables such as `FACTORY_WORKER_CONFIG`, `FACTORY_MODEL`, `PORT`
 and `FACTORY_DEMO` are not supported. See [concepts](concepts.md).

package/docs/recovery.md

@@ -51,7 +51,7 @@ verdict is `changes` or `blocked`, or at the normal approval gate. The CLI
 provides the same action:
 
 ```sh
-software-defence-factory revise JOB_ID --file /private/revision.md --state /private/state/project
+factory revise JOB_ID --file /private/revision.md --state /private/state/project
 ```
 
 Feedback must be nonempty and at most 4,000 characters. It is accumulated in the
@@ -193,8 +193,8 @@ separately from integration or deployment.
 Inspect the same installation before recovery:
 
 ```sh
-software-defence-factory status --state /private/state/project
-software-defence-factory publish JOB_ID --state /private/state/project
+factory status --state /private/state/project
+factory publish JOB_ID --state /private/state/project
 ```
 
 After a lost response or controller restart, repeat `publish`. The controller
@@ -300,8 +300,8 @@ provider writes. Inspect the exact branch in GitHub, then use the task action
 the CLI:
 
 ```sh
-software-defence-factory status --state /private/state/project
-software-defence-factory abandon-delivery JOB_ID --branch-sha INSPECTED_SHA --state /private/state/project
+factory status --state /private/state/project
+factory abandon-delivery JOB_ID --branch-sha INSPECTED_SHA --state /private/state/project
 ```
 
 The controller checks the latest run, saved delivery identity, current branch
@@ -339,11 +339,11 @@ Use one explicit starting point for a current software review with a returned
 
 ```sh
 # Existing default: restore admitted source, discarding candidate code from the next Build.
-software-defence-factory revise JOB_ID --file feedback.md --state PATH
+factory revise JOB_ID --file feedback.md --state PATH
 # Keep this job’s current immutable reviewed tree; keep its source/delivery baseline.
-software-defence-factory revise JOB_ID --file feedback.md --from reviewed-candidate --state PATH
+factory revise JOB_ID --file feedback.md --from reviewed-candidate --state PATH
 # Existing source replacement: resolve and retain a deliberately different baseline.
-software-defence-factory revise JOB_ID --file feedback.md --source-ref REF --state PATH
+factory revise JOB_ID --file feedback.md --source-ref REF --state PATH
 ```
 
 `--from admitted-source` names the default explicitly. `--from` and

package/docs/services.md

@@ -10,9 +10,9 @@ root controller. macOS can still run a local controller with `up`.
 Configure and install a runtime using the [quickstart](quickstart.md), then:
 
 ```sh
-software-defence-factory stop --state /absolute/private/state
-software-defence-factory service install --state /absolute/private/state
-software-defence-factory service status --state /absolute/private/state
+factory stop --state /absolute/private/state
+factory service install --state /absolute/private/state
+factory service status --state /absolute/private/state
 ```
 
 Installation enables and starts exactly this controller. It does not submit a
@@ -54,11 +54,11 @@ changes system-wide Docker, firewall or login configuration. Systemd retries
 startup every 15 seconds if Docker or the configured image is unavailable.
 
 ```sh
-software-defence-factory service stop --state /absolute/private/state
-software-defence-factory service start --state /absolute/private/state
-software-defence-factory service restart --state /absolute/private/state
-software-defence-factory service logs --state /absolute/private/state
-software-defence-factory service uninstall --state /absolute/private/state
+factory service stop --state /absolute/private/state
+factory service start --state /absolute/private/state
+factory service restart --state /absolute/private/state
+factory service logs --state /absolute/private/state
+factory service uninstall --state /absolute/private/state
 ```
 
 `up` and `stop` detect a managed installation and use its service manager, so a
@@ -77,12 +77,12 @@ The remote dashboard must bind to loopback and the machines must be reachable
 (for example through an existing private VPN). Use a configured SSH alias:
 
 ```sh
-software-defence-factory tunnel install --host worker --port 7345
-software-defence-factory tunnel status --host worker --port 7345
-software-defence-factory tunnel logs --host worker --port 7345
-software-defence-factory tunnel stop --host worker --port 7345
-software-defence-factory tunnel start --host worker --port 7345
-software-defence-factory tunnel uninstall --host worker --port 7345
+factory tunnel install --host worker --port 7345
+factory tunnel status --host worker --port 7345
+factory tunnel logs --host worker --port 7345
+factory tunnel stop --host worker --port 7345
+factory tunnel start --host worker --port 7345
+factory tunnel uninstall --host worker --port 7345
 ```
 
 Visit `http://127.0.0.1:7345`. The local and remote ports are intentionally equal
@@ -101,10 +101,10 @@ not a Factory network dependency. No root LaunchDaemon is installed.
 ## Updating an always-running controller
 
 ```sh
-software-defence-factory service update
-software-defence-factory service updates --auto on
-software-defence-factory service updates --auto status
-software-defence-factory service updates --auto off
+factory service update
+factory service updates --auto on
+factory service updates --auto status
+factory service updates --auto off
 ```
 
 `service update` manages all registered controllers for the current user. It

package/docs/setup.md

@@ -1,13 +1,13 @@
 # Factory Foundation: repository and execution setup
 
-The operator skill is available through `software-defence-factory foundation`.
+The operator skill is available through `factory foundation`.
 See [Factory concepts](concepts.md) for host, worker, harness and agent roles.
 
-Use this plan for a new installation or when moving an existing Factory to a
+Use this plan for a new installation or when moving an existing Factory to an
 execution host. Complete the applicable checkpoints in order and record the
 result in a **private** copy of the checklist below. The plan applies to any
-operator/worker names and any suitable private network; it requires no personal
-context system, particular VPN provider or Factory source checkout.
+operator/worker names and any suitable private network. Install the npm package
+on the execution host; a source checkout is unnecessary.
 
 The operator owns access and infrastructure choices. Factory maintainers own
 this plan and the linked command guides and update them with behavior changes.
@@ -32,9 +32,9 @@ installed package.
 One installation owns one repository and port. A synthetic qualification
 installation can provide a running dashboard while product controllers remain
 stopped. There is no multi-project controller or second scheduler hidden in
-this plan. Keep unrelated personal agent configuration on its existing host.
+this plan.
 
-For method-only adoption, run `software-defence-factory kit --output NEW_DIRECTORY`
+For method-only adoption, run `factory kit --output NEW_DIRECTORY`
 and follow [the adoption guide](../kit/README.md). The remaining host/runtime
 steps apply only when using Factory's optional controller.
 
@@ -75,9 +75,9 @@ work, and required host dependencies have a documented startup/recovery owner.
 ## 3. Install the package and qualify the runtime
 
 ```sh
-npm install --global software-defence-factory
-software-defence-factory --version
-software-defence-factory help
+npm install --global software-defence-factory@latest
+factory --version
+factory help
 ```
 
 Use a user-writable npm prefix or the existing Node manager; do not turn the
@@ -90,9 +90,9 @@ Node executable available. See [installation and updates](npm.md).
 Use a **separate synthetic state and unused port** to exercise the runtime:
 
 ```sh
-software-defence-factory demo --state /private/state/runtime-proof --port 7345
+factory demo --state /private/state/runtime-proof --port 7345
 # Inspect and finish the sample handoff before qualification.
-software-defence-factory qualify --state /private/state/runtime-proof
+factory qualify --state /private/state/runtime-proof
 ```
 
 These commands deliberately create synthetic jobs, including failed/interrupted
@@ -124,9 +124,9 @@ Before admitting development work, establish:
 Configure a new installation using [the quickstart](quickstart.md):
 
 ```sh
-software-defence-factory init --repo /absolute/path/to/app --harness pi --check "npm ci && npm test" --state /private/state/my-app --port 7331
-software-defence-factory install --state /private/state/my-app
-software-defence-factory doctor --state /private/state/my-app
+factory init --repo /absolute/path/to/app --harness pi --check "npm ci && npm test" --state /private/state/my-app --port 7331
+factory install --state /private/state/my-app
+factory doctor --state /private/state/my-app
 ```
 
 Replace the harness/check/paths with the accepted application profile. Plain
@@ -134,7 +134,7 @@ Replace the harness/check/paths with the accepted application profile. Plain
 it on the worker first and select its existing local tag instead:
 
 ```sh
-software-defence-factory install --image LOCAL_IMAGE_REF --state /private/state/my-app
+factory install --image LOCAL_IMAGE_REF --state /private/state/my-app
 ```
 
 This command checks the local Docker daemon, records and retains the exact image
@@ -184,7 +184,7 @@ delivery for this installation, configure the exact canonical repository and
 target while initializing it, for example:
 
 ```sh
-software-defence-factory init --repo /absolute/path/to/app --harness pi \
+factory init --repo /absolute/path/to/app --harness pi \
   --check "npm ci && npm test" --source-ref main \
   --delivery-provider github \
   --delivery-repository https://github.com/OWNER/REPO \
@@ -245,11 +245,11 @@ If queue ownership/state is uncertain, reconcile it before enabling autostart.
 On the Linux worker, select the state that should stay available:
 
 ```sh
-software-defence-factory stop --state /private/state/runtime-proof
-software-defence-factory service install --state /private/state/runtime-proof
-software-defence-factory service status --state /private/state/runtime-proof
-software-defence-factory service updates --auto on
-software-defence-factory service updates --auto status
+factory stop --state /private/state/runtime-proof
+factory service install --state /private/state/runtime-proof
+factory service status --state /private/state/runtime-proof
+factory service updates --auto on
+factory service updates --auto status
 ```
 
 Follow [services](services.md) for user lingering, existing Docker group
@@ -261,8 +261,8 @@ for the intended account through the host's administrator.
 On the operator machine, stop any old manual tunnel, then:
 
 ```sh
-software-defence-factory tunnel install --host factory-worker --port 7345
-software-defence-factory tunnel status --host factory-worker --port 7345
+factory tunnel install --host factory-worker --port 7345
+factory tunnel status --host factory-worker --port 7345
 ```
 
 Use the actual selected dashboard port on both sides. macOS tunnels start at

package/docs/web-verification.md

@@ -36,8 +36,8 @@ browser_image="$(docker image inspect --format '{{.Id}}' software-defence-factor
 Run the readiness check from the selected installation:
 
 ```sh
-software-defence-factory web probe --state /private/state/project
-software-defence-factory doctor --state /private/state/project
+factory web probe --state /private/state/project
+factory doctor --state /private/state/project
 ```
 
 The probe runs a real headless Chromium click and result assertion in a bounded,
@@ -150,11 +150,11 @@ normal sample handoff, stop that controller, then run the exact qualification
 command with the already-built browser image ID:
 
 ```sh
-software-defence-factory demo --state /private/state/sdf-web-proof --port 7348
+factory demo --state /private/state/sdf-web-proof --port 7348
 # Review and approve the synthetic demo task in its dashboard.
-software-defence-factory stop --state /private/state/sdf-web-proof
+factory stop --state /private/state/sdf-web-proof
 browser_image="$(docker image inspect --format '{{.Id}}' software-defence-factory-playwright:1.63.0)"
-software-defence-factory qualify-web --state /private/state/sdf-web-proof --image "$browser_image"
+factory qualify-web --state /private/state/sdf-web-proof --image "$browser_image"
 ```
 
 The installed command probes actual Chromium interaction, then runs a

package/docs/workflows.md

@@ -1,7 +1,7 @@
 # Roles, skills and work
 
 Read [Factory concepts](concepts.md) for the shared vocabulary. Inspect the actual
-installation with `software-defence-factory definition --state PATH`, or its
+installation with `factory definition --state PATH`, or its
 Agents, Skills and Definition pages. Both read the same effective catalog.
 
 Software follows **Implement → Check → Review → Accept & hand off**. Implement
@@ -87,18 +87,18 @@ GitHub projects, assignees and arbitrary issue form extensions are not applied.
 CLI equivalents (the selected controller must be running):
 
 ```sh
-software-defence-factory issue connection --state PATH
-software-defence-factory inbox --state PATH --page 1 --issue-state open
+factory issue connection --state PATH
+factory inbox --state PATH --page 1 --issue-state open
 # Explicit legacy execution-only JSON array:
-software-defence-factory inbox --state PATH --source factory
-software-defence-factory issue templates --state PATH
-software-defence-factory issue draft --state PATH --template bug-report.yml --sha TEMPLATE_SHA --file answers.json > draft.json
-software-defence-factory issue create --state PATH --draft draft.json --key release-board-fix-01
-software-defence-factory issue submissions --state PATH
-software-defence-factory issue recover --state PATH --key release-board-fix-01
+factory inbox --state PATH --source factory
+factory issue templates --state PATH
+factory issue draft --state PATH --template bug-report.yml --sha TEMPLATE_SHA --file answers.json > draft.json
+factory issue create --state PATH --draft draft.json --key release-board-fix-01
+factory issue submissions --state PATH
+factory issue recover --state PATH --key release-board-fix-01
 # Explicit execution, independent of creation:
-software-defence-factory issue start --state PATH --url URL --workflow software --brief-file operator.md
-software-defence-factory issue start --state PATH --file brief.md --title "Investigate supplied evidence" --workflow defence --source-ref main
+factory issue start --state PATH --url URL --workflow software --brief-file operator.md
+factory issue start --state PATH --file brief.md --title "Investigate supplied evidence" --workflow defence --source-ref main
 ```
 
 `--brief-file` is optional, UTF-8, at most 16000 characters and valid only with

package/factory/execution-profile.mjs

@@ -7,11 +7,12 @@ import { effectiveInferenceProvider } from './model-environment.mjs';
 import { expectedWebStories, webPolicyHash } from './web-verification.mjs';
 
 // Audited v1 protected evidence writers: 0.8.0 (380f749), 0.9.0 (cdaadef),
-// 0.9.1, 0.10.0 and 0.11.0 (unchanged protected evidence writers). Deliberately independent of VERSION: a release bump is not
+// 0.9.1, 0.10.0, 0.11.0 and 0.11.1 (unchanged protected evidence writers).
+// Deliberately independent of VERSION: a release bump is not
 // evidence compatibility. Re-audit this list for every trust-relevant writer,
 // isolation or validation change; remove versions whose guarantees no longer
 // satisfy current policy. See docs/npm.md. This predicate alone grants no trust.
-const SUPPORTED_EXECUTION_RUNTIMES_V1 = new Set(['0.8.0', '0.9.0', '0.9.1', '0.10.0', '0.11.0']);
+const SUPPORTED_EXECUTION_RUNTIMES_V1 = new Set(['0.8.0', '0.9.0', '0.9.1', '0.10.0', '0.11.0', '0.11.1']);
 
 export function isSupportedExecutionProfile(profile) {
   return profile?.version === 1 && SUPPORTED_EXECUTION_RUNTIMES_V1.has(profile.runtimeVersion);

package/factory/services.mjs

@@ -111,7 +111,7 @@ function environment() {
 }
 export function serviceDefinition(state) {
   configAt(state);
-  return systemdUnit({ description: 'Software & Defence Factory', argv: [process.execPath, join(ROOT, 'bin/software-defence-factory.mjs'), 'serve', '--state', state], directory: homedir(), environment: environment() });
+  return systemdUnit({ description: 'Factory', argv: [process.execPath, join(ROOT, 'bin/software-defence-factory.mjs'), 'serve', '--state', state], directory: homedir(), environment: environment() });
 }
 async function install(kind, state, flags) {
   userOnly();
@@ -145,7 +145,7 @@ async function install(kind, state, flags) {
   record.unit = `${id}.service`;
   record.file = process.platform === 'linux' ? join(userUnits, record.unit) : join(homedir(), 'Library/LaunchAgents', `${id}.plist`);
   record.log = join(records, `${id}.log`);
-  const definition = process.platform === 'linux' ? systemdUnit({ description: `Software & Defence Factory ${kind}`, argv, directory: homedir(), environment: record.environment })
+  const definition = process.platform === 'linux' ? systemdUnit({ description: `Factory ${kind}`, argv, directory: homedir(), environment: record.environment })
     : launchAgent({ id, argv, directory: homedir(), log: record.log, environment: record.environment });
   if (existsSync(record.file)) throw new Error(`Refusing to overwrite an unregistered service: ${record.file}`);
   mkdirSync(dirname(record.file), { recursive: true, mode: 0o700 }); mkdirSync(records, { recursive: true, mode: 0o700 });
@@ -235,7 +235,7 @@ async function performUpdate(latest, download) {
       priorVersions.set(record.id, value); return value;
     }));
     if (runningVersions.some(value => !/^\d+\.\d+\.\d+$/.test(value || ''))) throw new Error('Cannot verify the runtime version of a managed controller');
-    if (!newer(version, current) && runningVersions.every(value => !newer(version, value))) { console.log(`software-defence-factory ${current} is up to date.`); return; }
+    if (!newer(version, current) && runningVersions.every(value => !newer(version, value))) { console.log(`Factory ${current} is up to date.`); return; }
     const unowned = busyInstallations().filter(state => !live.some(record => record.state === state));
     if (unowned.length) throw new Error('Unmanaged controllers or executor fences block the update: ' + unowned.join(', '));
     // Reserve idle controllers before downloads. All mutating API actions are
@@ -289,7 +289,7 @@ function automaticUpdates(mode) {
   }
   if (existsSync(record)) { console.log('Scheduled updates are already installed.'); return; }
   if (existsSync(timer) || existsSync(service)) throw new Error('Refusing to overwrite an unregistered update unit');
-  const serviceText = systemdUnit({ description: 'Software & Defence Factory idle update', argv: [process.execPath, launcher(), 'service', 'update'], directory: homedir(), environment: environment(), oneshot: true });
+  const serviceText = systemdUnit({ description: 'Factory idle update', argv: [process.execPath, launcher(), 'service', 'update'], directory: homedir(), environment: environment(), oneshot: true });
   const timerText = `[Unit]\nDescription=Check Factory updates daily when idle\n\n[Timer]\nOnCalendar=daily\nRandomizedDelaySec=1h\nPersistent=true\n\n[Install]\nWantedBy=timers.target\n`;
   mkdirSync(userUnits, { recursive: true, mode: 0o700 });
   writeFileSync(service, serviceText, { mode: 0o600 }); writeFileSync(timer, timerText, { mode: 0o600 });

package/factory/ui/index.html

@@ -4,7 +4,7 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <meta name="color-scheme" content="dark" />
-    <title>Software &amp; Defence Factory</title>
+    <title>Factory — Software &amp; Defence</title>
     <script type="module" crossorigin src="/assets/index-BUCK1R7u.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-BQZGHA6-.css">
   </head>

package/factory/updates.mjs

@@ -114,14 +114,14 @@ export async function bootstrap(args) {
       const latest = await latestVersion();
       if (explicit && args[1] === '--check') { console.log(JSON.stringify({ current: selectedVersion, latest, available: newer(latest, selectedVersion), automatic: preferences.enabled })); return 0; }
       if (newer(latest, selectedVersion)) {
-        console.error(`Updating ${PACKAGE} ${selectedVersion} → ${latest}…`);
+        console.error(`Updating Factory (${PACKAGE}) ${selectedVersion} → ${latest}…`);
         installRelease(latest);
         // Downloads are immutable. A newly started controller keeps its version;
         // do not switch the next CLI process to a new release while it is active.
         if (busyInstallations().length) throw new Error('Update downloaded; activation deferred while an installation is running.');
         preferences.version = latest; save(preferencePath, preferences); selectedVersion = latest;
       }
-      if (explicit) { console.log(`${PACKAGE} ${selectedVersion} is up to date. Runtime, credentials and jobs were preserved.`); return 0; }
+      if (explicit) { console.log(`Factory ${selectedVersion} is up to date. Runtime, credentials and jobs were preserved.`); return 0; }
     } catch (error) {
       if (explicit) throw error;
       // An offline registry must never prevent a local command from working.

package/kit/README.md

@@ -1,6 +1,6 @@
 # Adopt the factory method
 
-Software & Defence Factory gives an existing app a shared method for development, security and review. Keep the app's architecture, code, CI, hosting and established instructions.
+Factory gives an existing app a shared method for development, security and review. Keep the app's architecture, code, CI, hosting and established instructions.
 
 ## With the local runtime
 
@@ -8,7 +8,7 @@ Use the CLI's `init` and installation workflow. Jobs receive policy and the six
 
 ## With your existing agent
 
-Export a new staging directory with `software-defence-factory kit --output NEW_DIRECTORY`. Give that directory to the app's agent and ask it to adopt the relevant method on a branch:
+Export a new staging directory with `factory kit --output NEW_DIRECTORY`. Give that directory to the app's agent and ask it to adopt the relevant method on a branch:
 
 > Read the app's instructions, architecture, tests and CI first. Apply the supplied factory method within its existing authority. Fill the installation record from the repository and known choices, merge intentionally, preserve existing files and report what was connected, tested or still missing. Start manually. Accounts, publishing and deployment follow my existing mandate.
 

package/kit/repository.md

@@ -81,7 +81,7 @@ at the intended SHA until the current runtime has cloned it, and compare the
 candidate's recorded base before acceptance. Admission-time source snapshots are
 tracked separately in Factory #28; naming a SHA in task text does not pin it.
 
-Submit the selected issue with `software-defence-factory run --issue URL --state
+Submit the selected issue with `factory run --issue URL --state
 PATH`, or submit a reviewed task file using `run --file`. Issue submission uses
 the operator's `gh` authentication and checks the issue against the configured
 origin. The dashboard and `issue create` can create a GitHub issue through the selected

package/operator-skills/factory-foundation/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: factory-foundation
-description: Prepare or assess a repository and its execution host for Software & Defence Factory, including CI, access, harness configuration, services and a bounded qualification.
+description: Prepare or assess a repository and its execution host for Factory, including CI, access, harness configuration, services and a bounded qualification.
 ---
 
 # Factory Foundation

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "software-defence-factory",
-  "version": "0.11.0",
-  "description": "Scoped software delivery and defence investigations with isolated jobs, evidence and review",
+  "version": "0.11.1",
+  "description": "Factory: scoped software delivery and defence investigations with isolated jobs, evidence and review",
   "type": "module",
   "license": "MIT",
   "engines": {
     "node": ">=22.13.0"
   },
   "bin": {
+    "factory": "bin/software-defence-factory.mjs",
     "software-defence-factory": "bin/software-defence-factory.mjs"
   },
   "repository": {

package/scripts/export-kit.mjs

@@ -30,7 +30,7 @@ if (args.length === 1 && args[0] === "--help") {
     // Repository-specific security contact links are deliberately not exported.
     // Read only the public kit allowlist, before creating anything at destination.
     const files = new Map([...sources].map(([target, source]) => [target, readFileSync(join(root, source))]));
-    files.set("START-HERE.md", Buffer.from("# Software & Defence Factory kit\n\nRead [the adoption guide](.factory-kit/README.md). The kit folders start with a dot and may be hidden in your file browser. This is a staged package; no app, workflow or service has been configured.\n"));
+    files.set("START-HERE.md", Buffer.from("# Factory kit\n\nRead [the adoption guide](.factory-kit/README.md). The kit folders start with a dot and may be hidden in your file browser. This is a staged package; no app, workflow or service has been configured.\n"));
     let sourceRevision = null, sourceDirty = null;
     try {
       const git = (args) => execFileSync("git", args, { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();