factory-ai 1.0.0

package/AGENTS.md

@@ -0,0 +1,3 @@
+# Factory AI Development
+
+Prefer the smallest correct change. Use test-first development. Never print or persist secrets. Preserve deterministic control-plane separation and container isolation. Run syntax, lint, tests, audit, Bicep, and shell validation before completion. For reviews prioritize data loss, privilege crossing, queue idempotency, retry behavior, Git safety, and missing tests.

package/ARCHITECTURE.md

@@ -0,0 +1,9 @@
+# Architecture
+
+The CEO submits one objective. A deterministic control service persists state and delegates planning to an isolated planner container. It validates the returned DAG, dispatches one container per task through Service Bus, records results, enforces tester/reviewer/security approval, and sends approved publication to a separate release service.
+
+The control service has no model, shell, Git, workspace, Docker, Key Vault secret-loading, or release implementation. Agent containers have bounded CPU, memory, PIDs, steps, output, runtime, filesystem mounts, commands, skills, and MCP tools. GitHub credentials remain on trusted host services.
+
+Durability comes from Service Bus peek-lock/redelivery, systemd supervision, a retained Premium SSD, atomic state writes, Git checkpoints, and GitHub pull requests. Benchmarked GPT-5.4 nano handles scouting, GPT-5.4 handles independent testing, Kimi K2.7-Code handles implementation, and GPT-5.6 handles planning, debugging, review, security, and release analysis.
+
+Trust boundaries: CEO input and repository content are untrusted; capability definitions are pinned and allowlisted; agent containers cannot publish; the release bot cannot bypass approval gates; Azure credentials are loaded from Key Vault into process memory.

package/CHANGELOG.md

@@ -0,0 +1,21 @@
+# Changelog
+
+All notable changes follow semantic versioning and the Keep a Changelog structure.
+
+## [Unreleased]
+
+### Added
+
+- Full-screen terminal administration console.
+- Telegram remote objective intake with chat allowlisting.
+- Azure and Bedrock provider wizard.
+- Durable evaluation, analytics, scaling, policy, extension, and recovery roadmap.
+
+## [1.0.0] - 2026-07-12
+
+### Added
+
+- Deterministic CTO control plane and isolated role workers.
+- Azure Service Bus durability, retained memory/state, Key Vault, and cost dashboard.
+- GPT-5.4 nano, GPT-5.4, GPT-5.6, Kimi, and Bedrock routing.
+- Gated GitHub delivery, MCP/skills, project memory, CI, security scans, and one-command setup.

package/CODE_OF_CONDUCT.md

@@ -0,0 +1,7 @@
+# Code of Conduct
+
+We are committed to a welcoming, harassment-free community. Be respectful, assume good intent, focus criticism on ideas and code, protect private information, and avoid disruptive or discriminatory behavior.
+
+Maintainers may remove content or participation that threatens safety, privacy, collaboration, or project integrity. Report conduct concerns privately through the repository security/contact channel. Reports will be reviewed promptly and handled confidentially where possible.
+
+This policy applies to project repositories, discussions, issues, pull requests, community spaces, and direct interactions related to Factory AI.

package/CONTRIBUTING.md

@@ -0,0 +1,17 @@
+# Contributing
+
+Use a branch and pull request. Keep changes small, add a failing test first, and preserve trust boundaries. Run:
+
+```bash
+npm ci
+npm run check
+npm run lint
+npm test
+npm audit --audit-level=high
+az bicep build --file infra/main.bicep --stdout >/dev/null
+bash -n bootstrap/setup.sh bootstrap/deploy-runtime.sh bin/factory
+```
+
+Validate package distribution with `npm pack --dry-run` and a clean-prefix install whenever setup, dependencies, package metadata, or the `factory` executable changes.
+
+Do not add unpinned dependencies, arbitrary MCP installation, direct base-branch pushes, secret values, or model-controlled release authority.

package/Dockerfile.worker

@@ -0,0 +1,19 @@
+FROM node:20.20.2-bookworm-slim
+
+RUN apt-get update \
+  && apt-get install -y --no-install-recommends git ripgrep ca-certificates \
+  && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /opt/agent-factory/app
+ENV PLAYWRIGHT_BROWSERS_PATH=/ms-playwright
+COPY package.json package-lock.json ./
+RUN npm ci --omit=dev \
+  && npx playwright install --with-deps chromium \
+  && chmod -R a+rX /ms-playwright \
+  && npm cache clean --force
+COPY src ./src
+COPY config ./config
+COPY capabilities ./capabilities
+
+USER node
+ENTRYPOINT ["node", "/opt/agent-factory/app/src/task-entry.js"]

package/GOVERNANCE.md

@@ -0,0 +1,21 @@
+# Governance
+
+Factory AI uses maintainer-led governance.
+
+## Roles
+
+- Contributors propose issues, documentation, tests, and code changes.
+- Maintainers triage work, review changes, manage releases, and enforce security boundaries.
+- The lead maintainer resolves decisions that lack consensus and owns release signing and trust-root changes.
+
+## Decisions
+
+Routine changes use pull-request review. Architecture, security-floor, extension trust, credential handling, and backward-incompatible changes require a written decision in the pull request and explicit maintainer approval.
+
+## Releases
+
+Releases follow semantic versioning. Every release must pass CI, tests, dependency audit, Gitleaks, Trivy, package inspection, and release-note review.
+
+## Security Floor
+
+Repository policy may tighten but never weaken container isolation, capability-free orchestration, secret boundaries, release gates, or least-privilege credentials.

package/HANDOFF.md

@@ -0,0 +1,23 @@
+# Factory AI Handoff
+
+## Product
+
+Azure-hosted autonomous coding factory with one CEO interface, deterministic CTO orchestration, isolated role agents, durable queues/state, curated skills/MCP, GitHub checkpoints, approval gates, CLI dashboard, and hourly reports.
+
+## Azure resources
+
+- Resource group: configured by `FACTORY_RESOURCE_GROUP`
+- VM: configured by `FACTORY_VM`
+- Service Bus: configured by `FACTORY_SERVICE_BUS`
+- Key Vault: configured by `FACTORY_KEY_VAULT`
+- Queues: `control-events`, `agent-tasks`, `release-tasks`
+
+Infrastructure is reproducible from `infra/main.bicep`. Runtime is installed from a pinned Git commit. See `ARCHITECTURE.md`, `RUNBOOK.md`, and `SECURITY.md` before changing production behavior.
+
+Global API keys belong in Key Vault, never repository `.env` files. Use `bin/factory secret` commands; temporary operator IP access is removed automatically after each command.
+
+For GitHub Enterprise Cloud, keep the `github.com` host. Run `bin/factory github connect ORG` with an organization-authorized `gh` session, then explicitly transfer repositories with `bin/factory github transfer OWNER/REPO ORG`.
+
+## Known platform limitation
+
+Private-repository branch protection and auto-merge depend on the GitHub account or organization plan. Factory AI leaves approved PRs open whenever repository policy does not permit auto-merge.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vedant Kumar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+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 AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,244 @@
+# Factory AI
+
+<div align="center">
+
+**Securely deploy your own autonomous software-engineering factory on Azure.**
+
+One CEO interface delegates to a deterministic CTO that coordinates isolated coding, testing, security, and release agents across Azure AI and Bedrock—then delivers verified GitHub pull requests with durable memory, recovery, and cost visibility.
+
+[![CI](https://github.com/itsvedantkumar/factory-ai/actions/workflows/ci.yml/badge.svg)](https://github.com/itsvedantkumar/factory-ai/actions/workflows/ci.yml)
+[![Node 20](https://img.shields.io/badge/node-20-339933?logo=node.js&logoColor=white)](https://nodejs.org/)
+[![Azure](https://img.shields.io/badge/runtime-Azure-0078D4?logo=microsoftazure)](https://azure.microsoft.com/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+
+</div>
+
+## Why Factory AI?
+
+Most coding-agent setups are interactive sessions pretending to be infrastructure. Factory AI is an actual delivery system:
+
+- Objectives survive terminal closures, model interruptions, VM reboots, and worker crashes.
+- The orchestrator cannot edit code, execute shell commands, access model credentials, or publish releases.
+- Every task runs in a bounded, disposable container and isolated Git branch.
+- Tester, reviewer, and security agents must approve before the trusted release bot opens a PR.
+- Project memory, queue state, costs, logs, and hourly progress remain visible from one CLI.
+
+## Quick Start
+
+Requirements: Node.js 20, [Azure CLI](https://learn.microsoft.com/cli/azure/install-azure-cli), [GitHub CLI](https://cli.github.com/), `az login`, and `gh auth login`.
+
+```bash
+npm install -g factory-ai
+factory setup
+```
+
+The arrow-key wizard handles the rest. A GitHub organization is not required; personal repositories work by default.
+
+1. Select Azure AI Foundry, AWS Bedrock, or hybrid routing.
+2. Select infrastructure region and optional GitHub Enterprise organization.
+3. Enter provider credentials through hidden prompts.
+4. Let the installer create Azure infrastructure, Key Vault secrets, model routing, and supervised services.
+5. Start shipping.
+
+```bash
+factory init ~/Projects/my-app
+factory submit MY_ORG/my-app "/goal ship authenticated health checks"
+factory ui
+```
+
+## Operator Experience
+
+```text
+╔═ FACTORY AI ════════════════════════════════════════════════╗
+  Worker active · queue 0 · DLQ 0 · Azure MTD INR 16,068.56
+  Objectives complete:12 running:2 failed:1
+
+  [running] Add authenticated health checks
+    succeeded  scout     GPT-5.4 nano  · inspect conventions
+    running    builder   GPT-5.6       · implement contract
+    blocked    tester    GPT-5.4       · verify behavior
+    blocked    reviewer  GPT-5.6       · review correctness
+    blocked    security  GPT-5.6       · assess boundaries
+    blocked    release   GPT-5.6       · publish reviewed PR
+╚══════════════════════════════════════════════════════════════╝
+```
+
+| Command | Purpose |
+| --- | --- |
+| `factory setup` | Interactive cloud/provider installation |
+| `factory ui` | Full-screen interactive admin console |
+| `factory submit OWNER/REPO "OBJECTIVE"` | Send one CEO objective |
+| `factory issue OWNER/REPO NUMBER` | Turn a GitHub issue into a tracked objective |
+| `factory telegram configure` | Configure allowlisted Telegram remote intake |
+| `factory dashboard` | Objectives, agents, models, queue, DLQ, and Azure cost |
+| `factory init PATH` | Create durable repo-local project context |
+| `factory doctor` | Services, storage, memory, and host health |
+| `factory queue` | Queue and dead-letter depth |
+| `factory logs` | Consolidated service logs |
+| `factory report` | Latest hourly executive report |
+| `factory pause` / `resume` | Pause or resume execution safely |
+| `factory secret set NAME` | Store a credential in global Key Vault |
+| `factory github connect ORG` | Connect GitHub Enterprise credentials |
+
+## Architecture
+
+```mermaid
+flowchart TD
+    CEO[CEO CLI] --> CQ[Control Queue]
+    CQ --> CTO[Deterministic CTO Control Plane]
+    CTO --> AQ[Agent Task Queue]
+    AQ --> P[Planner Container]
+    AQ --> S[Scout Container]
+    AQ --> B[Builder Container]
+    AQ --> T[Tester Container]
+    AQ --> V[Reviewer and Security Containers]
+    P & S & B & T & V --> CQ
+    CTO -->|approval gate passed| RQ[Release Queue]
+    RQ --> RB[Trusted Release Bot]
+    RB --> PR[GitHub Pull Request]
+    KV[Azure Key Vault] --> B
+    SB[(Retained State Disk)] --> CTO
+    MEM[Unified Project Memory] --> P
+```
+
+The CTO is deliberately capability-free. It stores state, validates DAGs, dispatches tasks, and enforces gates. Model calls, Git workspaces, shell tools, MCP servers, and release credentials live behind separate trust boundaries.
+
+See [ARCHITECTURE.md](ARCHITECTURE.md) for details.
+
+## Model Routing
+
+Defaults are evidence-based and role-specific:
+
+| Role | Default | Rationale |
+| --- | --- | --- |
+| Scout | GPT-5.4 nano | Low-cost search and repository inspection |
+| Simple builder task | Kimi K2.7-Code | Economy coding path, independently reviewed |
+| Complex/unspecified builder task | GPT-5.6 | Fail-safe implementation default |
+| Tester | GPT-5.4 | Independent behavioral verification |
+| Planner, debugger, reviewer, security, release | GPT-5.6 | Higher-judgment work |
+
+Any role can be overridden with an Azure deployment or `bedrock/MODEL_ID`. Bedrock uses the Converse tool API behind the same sandbox and approval gates.
+
+## Reliability
+
+- Azure Service Bus peek-lock delivery, duplicate detection, retries, and dead letters
+- systemd restart supervision and reboot recovery
+- Atomic objective state on a retained Premium SSD
+- One self-contained clone and branch per task
+- Continuous trusted Git checkpoint pushes
+- Bounded model steps, execution time, output, CPU, memory, and PIDs
+- Permanent failures become explicit objective results instead of stale tasks
+- Hourly durable executive reports
+
+The production smoke suite has verified worker `SIGKILL`, message redelivery, reboot persistence, gated PR publication, and content-filter failure handling.
+
+## Memory and Skills
+
+Every repository gets two memory layers:
+
+- Deterministic project events injected into future planner context
+- Pinned MCP knowledge-graph memory on retained storage
+
+Built-in progressive skills include `/goal`, `/loop`, project context, systematic debugging, TDD, verification, security review, dependency security, browser verification, release discipline, and token efficiency. Context7 and Playwright MCPs are pinned and role-scoped.
+
+Use `factory init PATH` to create `.agent-factory/` project, architecture, commands, decisions, risks, and handoff files without overwriting existing context.
+
+## Credentials
+
+Credentials never belong in repository `.env` files. Store them globally:
+
+```bash
+factory secret set SERVICE-API-KEY
+factory secret list
+factory secret copy SERVICE-API-KEY
+```
+
+Values are held in Azure Key Vault, loaded into trusted process memory, and passed only to role-required containers. Secret values are never displayed by the CLI.
+
+## GitHub Enterprise
+
+GitHub Enterprise Cloud continues to use `github.com`:
+
+```bash
+gh auth refresh -h github.com -s admin:org,repo,workflow,read:org
+factory github status
+factory github connect YOUR_ORG
+factory github transfer OWNER/REPO YOUR_ORG
+```
+
+Organization rulesets can then enforce private-repo status checks, reviews, and auto-merge.
+
+## Telegram Remote Control
+
+Create a bot with `@BotFather`, obtain your numeric chat ID, then run:
+
+```bash
+factory telegram configure
+```
+
+Only explicitly allowlisted chat IDs are accepted. Supported commands:
+
+```text
+/submit OWNER/REPO objective
+/goal OWNER/REPO objective
+/loop OWNER/REPO objective
+/status
+/help
+```
+
+Telegram cannot run shell commands, read secrets, modify release policy, or bypass review gates. Durable update offsets prevent duplicate objectives after restarts.
+
+## Security
+
+- No VM public IP or inbound network path
+- Stable outbound-only NAT
+- Managed identity and RBAC
+- Subnet-restricted Key Vault
+- Trusted Launch, Secure Boot, and vTPM
+- Read-only worker image, dropped capabilities, `no-new-privileges`, and no Docker socket
+- GitHub publication isolated from model-controlled containers
+- Pinned dependencies, MCPs, skills, and runtime revisions
+- CI, Dependabot, npm audit, Trivy vulnerability/secret/misconfiguration scans
+
+Read [SECURITY.md](SECURITY.md) before adding tools, providers, or permissions.
+
+## Development
+
+```bash
+git clone https://github.com/itsvedantkumar/factory-ai.git
+cd factory-ai
+npm ci
+npm run check
+npm run lint
+npm test
+npm audit --audit-level=high
+az bicep build --file infra/main.bicep --stdout >/dev/null
+bash -n bootstrap/setup.sh bootstrap/deploy-runtime.sh bin/factory
+npm pack --dry-run
+```
+
+## Documentation
+
+| Document | Purpose |
+| --- | --- |
+| [ARCHITECTURE.md](ARCHITECTURE.md) | Runtime, boundaries, and data flow |
+| [RUNBOOK.md](RUNBOOK.md) | Operations, recovery, and cost control |
+| [SECURITY.md](SECURITY.md) | Security policy and extension rules |
+| [CONTRIBUTING.md](CONTRIBUTING.md) | Development and verification contract |
+| [HANDOFF.md](HANDOFF.md) | Team/friend transfer context |
+| [docs/COMPARISON.md](docs/COMPARISON.md) | Honest comparison with paid alternatives |
+| [ROADMAP.md](ROADMAP.md) | Planned platform and ecosystem work |
+| [GOVERNANCE.md](GOVERNANCE.md) | Decision and release governance |
+| [SUPPORT.md](SUPPORT.md) | Community support process |
+| [CODE_OF_CONDUCT.md](CODE_OF_CONDUCT.md) | Community standards |
+
+## Current Limitations
+
+- Azure Cost Management data is authoritative but delayed.
+- Private-repo auto-merge requires an eligible GitHub Team/Enterprise organization policy.
+- Kimi is used only for explicitly simple coding tasks until broader evaluations justify expansion.
+- npm releases are verified and published with provenance through GitHub Actions.
+
+## License
+
+[MIT](LICENSE)

package/ROADMAP.md

@@ -0,0 +1,23 @@
+# Roadmap
+
+## Near Term
+
+- Evaluation Lab with model promotion and rollback evidence.
+- Enhanced TUI timeline, diffs, files, checks, and safe takeover leases.
+- Telegram remote objective status and completion notifications.
+- Multi-repository objective schema and release groups.
+
+## Platform
+
+- Policy engine and risk-based model/tool/release controls.
+- OpenTelemetry and Application Insights traces and metrics.
+- VMSS queue autoscaling with regular and Spot workers.
+- Signed curated extension catalog and lockfile.
+- Blob-backed state, automated snapshots, and recovery drills.
+
+## Ecosystem
+
+- Slack, Teams, Linear, and Jira adapters.
+- VS Code integration and optional signed macOS application.
+- Organization analytics and cost per accepted PR.
+- Optional managed control plane and support offering.

package/RUNBOOK.md

@@ -0,0 +1,42 @@
+# Operator Runbook
+
+## Daily commands
+
+```bash
+bin/factory setup
+bin/factory github status
+bin/factory github connect YOUR_ENTERPRISE_ORG
+bin/factory submit OWNER/REPO "/loop ship the objective"
+bin/factory init /path/to/new-project
+bin/factory secret list
+bin/factory secret set SERVICE-NAME-API-KEY
+bin/factory secret copy SERVICE-NAME-API-KEY
+bin/factory telegram configure
+bin/factory telegram status
+bin/factory dashboard
+bin/factory queue
+bin/factory logs
+bin/factory report
+bin/factory doctor
+bin/factory pause
+bin/factory resume
+```
+
+Fresh install:
+
+```bash
+npm install -g factory-ai
+factory setup
+```
+
+Override defaults with `FACTORY_RESOURCE_GROUP`, `FACTORY_VM`, and `FACTORY_SERVICE_BUS`.
+
+## Recovery
+
+If a worker dies, systemd restarts it and Service Bus redelivers after lock expiry. Do not manually duplicate the task. Check `dashboard`, then `logs`, then queue dead-letter counts. Preserve objective state before purging dead letters.
+
+Deploy only a full commit SHA through `bootstrap/deploy-runtime.sh`. Setup builds an immutable local worker image and restarts supervised services. State lives at `/opt/agent-factory/state` on the retained data disk.
+
+## Cost control
+
+Pause workers before deallocating the VM. Deallocation stops compute but not disk, NAT, Service Bus, Key Vault, or model charges. Resume and run `doctor` after startup.

package/SECURITY.md

@@ -0,0 +1,7 @@
+# Security Policy
+
+Report vulnerabilities privately to the repository owner. Do not open public issues containing credentials, exploit details, or customer repository data.
+
+Never commit secrets. Azure model and GitHub credentials belong in Key Vault. The control service must remain capability-free. New MCP servers, skills, dependencies, commands, and network access require pinning, role scoping, tests, and review. Agent containers must not receive GitHub credentials or the Docker socket.
+
+Before release run `npm audit --audit-level=high`, tests, lint, Bicep compilation, shell syntax checks, secret scanning, and container scanning. Rotate credentials after confirmed disclosure.

package/SUPPORT.md

@@ -0,0 +1,7 @@
+# Support
+
+Use GitHub Discussions for questions and design conversations. Use issues for reproducible bugs and scoped feature requests. Use private vulnerability reporting or the process in `SECURITY.md` for security concerns.
+
+Include Factory AI version, operating system, provider, relevant redacted logs, expected behavior, and reproduction steps. Never attach credentials, complete environment files, private source code, or unredacted cloud responses.
+
+Community support is best effort. There is currently no commercial SLA.