factory-ai 1.0.2 → 1.2.0

package/ARCHITECTURE.md

@@ -4,6 +4,6 @@ The CEO submits one objective. A deterministic control service persists state an
 
 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.
+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 simple implementation, GPT-5.5 handles complex 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

@@ -11,6 +11,22 @@ All notable changes follow semantic versioning and the Keep a Changelog structur
 - Azure and Bedrock provider wizard.
 - Durable evaluation, analytics, scaling, policy, extension, and recovery roadmap.
 
+## [1.2.0] - 2026-07-13
+
+### Added
+
+- Telegram natural-language objectives, default repositories, objective lookup, and automatic progress/completion notifications.
+- Six-hour verified stable updates with CI/security gates, durable version records, major-version blocking, and rollback.
+
+## [1.1.0] - 2026-07-13
+
+### Added
+
+- GPT-5.5 as the benchmarked default implementation model, with Kimi retained for explicitly simple tasks.
+- Per-role step/output budgets and per-model input/cache/output token telemetry.
+- Cache-friendly prompt ordering and compact deterministic memory.
+- Bounded line-range reads, listings, command output, MCP output, and scanner evidence.
+
 ## [1.0.2] - 2026-07-13
 
 ### Fixed

package/README.md

@@ -57,7 +57,7 @@ factory ui
 
   [running] Add authenticated health checks
     succeeded  scout     GPT-5.4 nano  · inspect conventions
-    running    builder   GPT-5.6       · implement contract
+    running    builder   GPT-5.5       · implement contract
     blocked    tester    GPT-5.4       · verify behavior
     blocked    reviewer  GPT-5.6       · review correctness
     blocked    security  GPT-5.6       · assess boundaries
@@ -115,12 +115,25 @@ Defaults are evidence-based and role-specific:
 | --- | --- | --- |
 | 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 |
+| Complex/unspecified builder task | GPT-5.5 | Faster benchmarked 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.
 
+## Token and Cost Efficiency
+
+Factory AI minimizes tokens before relying on cheaper models:
+
+- GPT-5.4 nano scouts, Kimi handles explicitly simple coding, GPT-5.5 handles complex coding, and GPT-5.6 is reserved for high-judgment roles.
+- Stable guardrail/skill prompt prefixes improve provider prompt-cache reuse.
+- Every role has explicit step and output-token budgets.
+- File reads are line-ranged and bounded; listings, commands, MCP output, memory, and scanner evidence are truncated with continuation hints.
+- Read-only roles do not receive write-tool schemas.
+- Planner memory is compact, repository-scoped, and limited to recent verified events.
+- Dashboard and TUI track input, cached-input, and output tokens by model.
+- The planner is instructed to produce the smallest valid DAG, avoiding duplicate agents.
+
 ## Reliability
 
 - Azure Service Bus peek-lock delivery, duplicate detection, retries, and dead letters
@@ -188,7 +201,20 @@ Only explicitly allowlisted chat IDs are accepted. Supported commands:
 /help
 ```
 
-Telegram cannot run shell commands, read secrets, modify release policy, or bypass review gates. Durable update offsets prevent duplicate objectives after restarts.
+Set a default repository with `/repo OWNER/REPO`, then send plain-text instructions without a command. `/recent` lists recent objectives and `/objective ID` shows task-level detail. Factory AI automatically pushes deduplicated status, active-agent, completion, PR, failure, and blocker updates to the originating chat.
+
+Telegram cannot run shell commands, read secrets, modify release policy, or bypass review gates. Durable update offsets, repository preferences, and objective subscriptions survive restarts.
+
+## Verified Automatic Updates
+
+The VM checks npm stable releases every six hours with a randomized delay. Updates are accepted only when:
+
+- The release remains within the installed major version.
+- npm `gitHead` resolves to the exact GitHub commit.
+- The commit has successful CI.
+- A fresh isolated clone passes install, syntax, lint, tests, dependency audit, Bicep, shell validation, and Gitleaks.
+
+The updater records the installed version on retained storage and restores the previous commit if deployment fails. Major upgrades always require explicit operator action.
 
 ## Security
 

package/RUNBOOK.md

@@ -31,6 +31,8 @@ factory setup
 
 Override defaults with `FACTORY_RESOURCE_GROUP`, `FACTORY_VM`, and `FACTORY_SERVICE_BUS`.
 
+Verified stable updates run every six hours through `factory-ai-update.timer`. Inspect with `systemctl status factory-ai-update.timer` and `journalctl -u factory-ai-update.service`. Automatic major-version upgrades are intentionally blocked.
+
 ## 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.

package/bootstrap/auto-update.sh

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+exec 9>/var/lock/factory-ai-update.lock
+flock -n 9 || { printf 'Factory AI update already running.\n'; exit 0; }
+
+app=/opt/agent-factory/app
+state=/opt/agent-factory/state
+status=$(FACTORY_PACKAGE_FILE="$app/package.json" node "$app/src/updater.js")
+available=$(jq -r .updateAvailable <<<"$status")
+[[ $available == true ]] || { printf 'Factory AI is current: %s\n' "$(jq -r .current <<<"$status")"; exit 0; }
+
+version=$(jq -r .latest <<<"$status")
+commit=$(jq -r .gitHead <<<"$status")
+[[ $commit =~ ^[0-9a-f]{40}$ ]] || { printf 'npm release does not contain a valid gitHead.\n' >&2; exit 1; }
+
+set -a
+source /etc/agent-factory.env
+set +a
+github_token=$(az keyvault secret show --vault-name "$KEY_VAULT_NAME" --name github-token --query value --output tsv)
+checks=$(GH_TOKEN="$github_token" gh api "repos/itsvedantkumar/factory-ai/commits/$commit/check-runs" --jq '[.check_runs[] | select(.name == "verify") | .conclusion] | any(. == "success")')
+[[ $checks == true ]] || { printf 'Candidate commit lacks successful CI verification.\n' >&2; exit 1; }
+
+temporary=$(mktemp -d /var/tmp/factory-ai-update.XXXXXX)
+trap 'rm -rf "$temporary"; unset github_token' EXIT
+previous_commit=$(jq -r '.commit // empty' "$state/runtime-version.json" 2>/dev/null || true)
+cp "$app/bootstrap/deploy-runtime.sh" "$temporary/rollback-deploy.sh"
+GH_TOKEN="$github_token" gh repo clone itsvedantkumar/factory-ai "$temporary/source" -- --no-checkout
+git -C "$temporary/source" checkout --detach "$commit"
+test "$(git -C "$temporary/source" rev-parse HEAD)" = "$commit"
+
+npm ci --prefix "$temporary/source"
+npm run check --prefix "$temporary/source"
+npm run lint --prefix "$temporary/source"
+npm test --prefix "$temporary/source"
+npm audit --prefix "$temporary/source" --audit-level=high
+az bicep build --file "$temporary/source/infra/main.bicep" --stdout >/dev/null
+bash -n "$temporary/source/bootstrap/setup.sh" "$temporary/source/bootstrap/deploy-runtime.sh" "$temporary/source/bin/factory"
+docker run --rm --read-only --volume "$temporary/source:/workspace:ro" \
+  zricethezav/gitleaks@sha256:c00b6bd0aeb3071cbcb79009cb16a60dd9e0a7c60e2be9ab65d25e6bc8abbb7f \
+  detect --source /workspace --redact --no-banner --exit-code 1
+
+printf 'Deploying Factory AI %s (%s)\n' "$version" "$commit"
+if ! bash "$temporary/source/bootstrap/deploy-runtime.sh" \
+  KEY_VAULT_NAME "$KEY_VAULT_NAME" \
+  SERVICE_BUS_NAMESPACE "$SERVICE_BUS_NAMESPACE" \
+  SERVICE_BUS_QUEUE code-tasks \
+  SOURCE_REPOSITORY itsvedantkumar/factory-ai \
+  SOURCE_REF "$commit"; then
+  printf 'Candidate deployment failed. Restoring previous runtime.\n' >&2
+  if [[ $previous_commit =~ ^[0-9a-f]{40}$ ]]; then
+    bash "$temporary/rollback-deploy.sh" \
+      KEY_VAULT_NAME "$KEY_VAULT_NAME" \
+      SERVICE_BUS_NAMESPACE "$SERVICE_BUS_NAMESPACE" \
+      SERVICE_BUS_QUEUE code-tasks \
+      SOURCE_REPOSITORY itsvedantkumar/factory-ai \
+      SOURCE_REF "$previous_commit"
+  fi
+  exit 1
+fi
+printf 'Factory AI updated to %s.\n' "$version"

package/bootstrap/deploy-runtime.sh

@@ -72,3 +72,11 @@ FACTORY_MODEL_REVIEWER="${FACTORY_MODEL_REVIEWER:-}" \
 FACTORY_MODEL_SECURITY="${FACTORY_MODEL_SECURITY:-}" \
 FACTORY_MODEL_RELEASE="${FACTORY_MODEL_RELEASE:-}" \
 bash /opt/agent-factory/app/bootstrap/setup.sh
+install -d -o factory -g factory -m 0750 /opt/agent-factory/state
+version=$(node -p 'require("/opt/agent-factory/app/package.json").version')
+jq -n --arg version "$version" --arg commit "$SOURCE_REF" --arg repository "$SOURCE_REPOSITORY" \
+  '{version:$version,commit:$commit,repository:$repository,installedAt:(now|todate)}' \
+  > /opt/agent-factory/state/runtime-version.json.tmp
+chown factory:factory /opt/agent-factory/state/runtime-version.json.tmp
+chmod 0640 /opt/agent-factory/state/runtime-version.json.tmp
+mv /opt/agent-factory/state/runtime-version.json.tmp /opt/agent-factory/state/runtime-version.json

package/bootstrap/factory-ai-update.service

@@ -0,0 +1,17 @@
+[Unit]
+Description=Factory AI verified stable update
+After=network-online.target docker.service
+Wants=network-online.target
+Requires=docker.service
+
+[Service]
+Type=oneshot
+User=root
+Group=root
+ExecStart=/opt/agent-factory/app/bootstrap/auto-update.sh
+Nice=10
+IOSchedulingClass=best-effort
+IOSchedulingPriority=7
+PrivateTmp=true
+ProtectHome=true
+UMask=0027

package/bootstrap/factory-ai-update.timer

@@ -0,0 +1,10 @@
+[Unit]
+Description=Check for verified Factory AI updates every six hours
+
+[Timer]
+OnCalendar=*-*-* 00/6:00:00
+RandomizedDelaySec=30m
+Persistent=true
+
+[Install]
+WantedBy=timers.target

package/bootstrap/setup.sh

@@ -114,11 +114,15 @@ install -m 0644 "$APP_DIR/bootstrap/agent-factory-release.service" /etc/systemd/
 install -m 0644 "$APP_DIR/bootstrap/agent-factory-reporter.service" /etc/systemd/system/agent-factory-reporter.service
 install -m 0644 "$APP_DIR/bootstrap/agent-factory-reporter.timer" /etc/systemd/system/agent-factory-reporter.timer
 install -m 0644 "$APP_DIR/bootstrap/agent-factory-telegram.service" /etc/systemd/system/agent-factory-telegram.service
+install -m 0755 "$APP_DIR/bootstrap/auto-update.sh" /opt/agent-factory/app/bootstrap/auto-update.sh
+install -m 0644 "$APP_DIR/bootstrap/factory-ai-update.service" /etc/systemd/system/factory-ai-update.service
+install -m 0644 "$APP_DIR/bootstrap/factory-ai-update.timer" /etc/systemd/system/factory-ai-update.timer
 systemctl daemon-reload
 systemctl enable --now agent-factory-worker.service
 systemctl enable --now agent-factory-control.service
 systemctl enable --now agent-factory-release.service
 systemctl enable --now agent-factory-reporter.timer
 systemctl enable --now agent-factory-telegram.service
+systemctl enable --now factory-ai-update.timer
 systemctl restart agent-factory-control.service agent-factory-worker.service agent-factory-release.service
 echo "Agent factory worker installed"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factory-ai",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "Deploy a private autonomous coding-agent factory on Azure: isolated builders, testers, security reviewers, durable orchestration, multi-model routing, memory, cost controls, and gated GitHub pull requests.",
   "private": false,
   "license": "MIT",

package/src/agent-runner.js

@@ -24,6 +24,15 @@ function endpointForRoute(route, role, environment) {
   return { baseUrl, apiKey, model };
 }
 
+function budgetFor(task) {
+  if (task.role === "scout") return { maxSteps: 14, maxOutputTokens: 1200 };
+  if (task.role === "builder" && task.complexity === "simple") return { maxSteps: 20, maxOutputTokens: 2400 };
+  if (task.role === "builder") return { maxSteps: 32, maxOutputTokens: 3200 };
+  if (task.role === "debugger") return { maxSteps: 36, maxOutputTokens: 3200 };
+  if (["tester", "reviewer", "security"].includes(task.role)) return { maxSteps: 22, maxOutputTokens: 1800 };
+  return { maxSteps: 22, maxOutputTokens: 2200 };
+}
+
 export class AzureAgentRunner {
   constructor(config, registry, {
     environment = process.env,
@@ -42,40 +51,56 @@ export class AzureAgentRunner {
       `ALLOWLISTED SKILL ${item.name}@${item.version}:\n${await readFile(item.path, "utf8")}`
     )));
     return [
-      `You are the isolated ${task.role} subagent for CEO objective: ${objective.objective}`,
-      task.instructions,
+      `You are a Factory AI isolated ${task.role} subagent.`,
       "Work only in the assigned repository. Never inspect credentials, push Git refs, deploy, or install global tools.",
       "Use tools for evidence. Make the smallest correct change and verify every completion claim.",
-      prompt,
-      ...skills,
       'Return only JSON: {"summary":"concise outcome","checks":["command/result"],"risks":["remaining risk"],"approval":"approved|changes_requested|not_applicable"}.',
+      ...skills,
+      `CEO objective: ${objective.objective}`,
+      task.instructions,
+      prompt,
     ].join("\n\n");
   }
 
   harness(task, directory, additionalTools = {}) {
     const role = task.role;
     const route = modelForTask(task, this.environment);
-    const tools = { ...createWorkspaceTools(directory), ...additionalTools };
-    const maxSteps = role === "scout" ? 20 : 40;
+    const workspaceTools = createWorkspaceTools(directory);
+    if (!["builder", "debugger"].includes(role)) delete workspaceTools.write_file;
+    const tools = { ...workspaceTools, ...additionalTools };
+    const budget = budgetFor(task);
     if (route.startsWith("bedrock/")) {
       return this.createBedrockHarness({
         region: this.environment.AWS_REGION ?? "us-east-1",
         model: route.slice("bedrock/".length),
         tools,
-        maxSteps,
+        ...budget,
       });
     }
-    return this.createHarness({ ...endpointForRoute(route, role, this.environment), tools, timeoutMs: this.config.timeoutMs, maxSteps });
+    return this.createHarness({ ...endpointForRoute(route, role, this.environment), tools, timeoutMs: this.config.timeoutMs, ...budget });
   }
 
   async invoke({ objective, task, directory, prompt }) {
     const capabilities = selectCapabilities(this.registry, task.role, task.capabilities);
     const mcp = await connectMcpTools(capabilities);
+    const started = Date.now();
     try {
       const response = await this.harness(task, directory, mcp.tools).run(
         await this.promptForTask(objective, task, prompt, capabilities),
       );
-      return parseJson(response.text);
+      return {
+        ...parseJson(response.text),
+        telemetry: {
+          model: modelForTask(task, this.environment),
+          steps: response.steps ?? 0,
+          durationMs: Date.now() - started,
+          usage: {
+            inputTokens: response.usage?.inputTokens ?? 0,
+            cachedInputTokens: response.usage?.cachedInputTokens ?? 0,
+            outputTokens: response.usage?.outputTokens ?? 0,
+          },
+        },
+      };
     } finally {
       await mcp.close();
     }
@@ -90,15 +115,16 @@ export class AzureAgentRunner {
       ...Object.entries(this.registry.skills ?? {}),
       ...Object.entries(this.registry.mcp ?? {}),
     ].map(([name, item]) => [name, { version: item.version, roles: item.roles }]));
-    const prompt = `You are a planner subagent. Decompose the objective into a small executable DAG.
-Objective: ${objective.objective}
-Verified prior project context: ${JSON.stringify(projectContext)}
+    const prompt = `You are a Factory AI planner subagent. Decompose objectives into the smallest executable DAG.
 Allowed roles: scout, builder, tester, debugger, reviewer, security, release.
 Allowed capabilities: ${JSON.stringify(registrySummary)}
 Include tester, reviewer, and security ancestors of exactly one terminal release task.
 Return only JSON: {"executiveIntent":"...","tasks":[{"id":"...","role":"...","title":"...","instructions":"...","dependsOn":[],"capabilities":[],"complexity":"simple|complex"}]}
 
-${plannerSkills.join("\n\n")}`;
+${plannerSkills.join("\n\n")}
+
+Objective: ${objective.objective}
+Verified prior project context: ${JSON.stringify(projectContext).slice(0, 12000)}`;
     const mcp = await connectMcpTools(plannerCapabilities);
     try {
       const response = await this.harness({ role: "planner", complexity: "complex" }, directory, mcp.tools).run(prompt);

package/src/azure-harness.js

@@ -27,6 +27,7 @@ export class AzureResponsesHarness {
     tools,
     fetch = globalThis.fetch,
     maxSteps = 40,
+    maxOutputTokens = 4096,
     retries = 4,
     timeoutMs = 180_000,
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
@@ -37,6 +38,7 @@ export class AzureResponsesHarness {
     this.tools = tools;
     this.fetch = fetch;
     this.maxSteps = maxSteps;
+    this.maxOutputTokens = maxOutputTokens;
     this.retries = retries;
     this.timeoutMs = timeoutMs;
     this.sleep = sleep;
@@ -79,15 +81,20 @@ export class AzureResponsesHarness {
     let input = prompt;
     let previousResponseId;
     const definitions = toolDefinitions(this.tools);
+    const usage = { inputTokens: 0, cachedInputTokens: 0, outputTokens: 0 };
     for (let step = 0; step < this.maxSteps; step += 1) {
       const response = await this.request({
         model: this.model,
         input,
         ...(previousResponseId ? { previous_response_id: previousResponseId } : {}),
         tools: definitions,
+        max_output_tokens: this.maxOutputTokens,
       });
+      usage.inputTokens += response.usage?.input_tokens ?? 0;
+      usage.cachedInputTokens += response.usage?.input_tokens_details?.cached_tokens ?? 0;
+      usage.outputTokens += response.usage?.output_tokens ?? 0;
       const calls = (response.output ?? []).filter((item) => item.type === "function_call");
-      if (calls.length === 0) return { text: outputText(response), responseId: response.id, steps: step + 1 };
+      if (calls.length === 0) return { text: outputText(response), responseId: response.id, steps: step + 1, usage };
       const outputs = [];
       for (const call of calls) {
         const tool = this.tools[call.name];

package/src/bedrock-harness.js

@@ -11,11 +11,12 @@ function definitions(tools) {
 }
 
 export class BedrockHarness {
-  constructor({ client, region = process.env.AWS_REGION ?? "us-east-1", model, tools, maxSteps = 40 }) {
+  constructor({ client, region = process.env.AWS_REGION ?? "us-east-1", model, tools, maxSteps = 40, maxOutputTokens = 4096 }) {
     this.client = client ?? new BedrockRuntimeClient({ region });
     this.model = model;
     this.tools = tools;
     this.maxSteps = maxSteps;
+    this.maxOutputTokens = maxOutputTokens;
   }
 
   async run(prompt) {
@@ -25,6 +26,7 @@ export class BedrockHarness {
       const response = await this.client.send(new ConverseCommand({
         modelId: this.model,
         messages,
+        inferenceConfig: { maxTokens: this.maxOutputTokens },
         ...(Object.keys(this.tools).length ? { toolConfig: { tools: definitions(this.tools) } } : {}),
       }));
       usage.inputTokens += response.usage?.inputTokens ?? 0;

package/src/dashboard.js

@@ -123,6 +123,20 @@ export function aggregateDashboard({ states = [], queue = {}, cost = null, runti
   });
   const summary = {};
   for (const objective of objectives) summary[objective.status ?? "unknown"] = (summary[objective.status ?? "unknown"] ?? 0) + 1;
+  const modelUsage = {};
+  for (const state of states) {
+    for (const result of Object.values(state.results ?? {})) {
+      const telemetry = result.telemetry;
+      if (!telemetry?.model) continue;
+      const current = modelUsage[telemetry.model] ?? { tasks: 0, inputTokens: 0, cachedInputTokens: 0, outputTokens: 0, durationMs: 0 };
+      current.tasks += 1;
+      current.inputTokens += telemetry.usage?.inputTokens ?? 0;
+      current.cachedInputTokens += telemetry.usage?.cachedInputTokens ?? 0;
+      current.outputTokens += telemetry.usage?.outputTokens ?? 0;
+      current.durationMs += telemetry.durationMs ?? 0;
+      modelUsage[telemetry.model] = current;
+    }
+  }
   const startedAt = runtime.startedAt ? new Date(runtime.startedAt) : null;
   return {
     generatedAt: now.toISOString(),
@@ -133,6 +147,7 @@ export function aggregateDashboard({ states = [], queue = {}, cost = null, runti
     queue: { active: queue.active ?? 0, deadLetter: queue.deadLetter ?? 0 },
     cost,
     summary: { objectives: summary },
+    modelUsage,
     objectives,
     warnings,
   };
@@ -150,6 +165,10 @@ export function renderDashboard(dashboard, { width = 100 } = {}) {
     `Objectives ${Object.entries(dashboard.summary.objectives).map(([state, count]) => `${state}:${count}`).join(" ") || "none"}`,
   ];
   if (dashboard.cost) lines.push(`Azure MTD ${dashboard.cost.currency} ${dashboard.cost.monthToDate.toFixed(2)} · billing data may be delayed`);
+  const totalInput = Object.values(dashboard.modelUsage ?? {}).reduce((sum, item) => sum + item.inputTokens, 0);
+  const totalCached = Object.values(dashboard.modelUsage ?? {}).reduce((sum, item) => sum + item.cachedInputTokens, 0);
+  const totalOutput = Object.values(dashboard.modelUsage ?? {}).reduce((sum, item) => sum + item.outputTokens, 0);
+  if (totalInput || totalOutput) lines.push(`Tokens input ${totalInput} · cached ${totalCached} · output ${totalOutput}`);
   for (const objective of dashboard.objectives) {
     lines.push("", `[${objective.status}] ${objective.id} ${objective.objective}`);
     for (const task of objective.tasks) lines.push(`  ${task.state.padEnd(9)} ${task.role.padEnd(9)} ${task.model} · ${task.title ?? task.id}`);

package/src/mcp-tools.js

@@ -1,5 +1,6 @@
 function renderContent(result) {
-  return (result.content ?? []).map((item) => item.type === "text" ? item.text : JSON.stringify(item)).join("\n");
+  const value = (result.content ?? []).map((item) => item.type === "text" ? item.text : JSON.stringify(item)).join("\n");
+  return value.length > 32_000 ? `${value.slice(0, 32_000)}\n[TRUNCATED: request narrower MCP output]` : value;
 }
 
 async function defaultConnect(capability) {

package/src/operator.js

@@ -21,7 +21,16 @@ export function createOperator(environment = process.env) {
   const vm = environment.FACTORY_VM ?? "agent-factory-vm";
   const namespace = environment.FACTORY_SERVICE_BUS ?? "";
   const vault = environment.FACTORY_KEY_VAULT ?? "";
-  const remote = async (script) => extractRunCommand(await command("az", ["vm", "run-command", "invoke", "--resource-group", resourceGroup, "--name", vm, "--command-id", "RunShellScript", "--scripts", script, "--query", "value[0].message", "--output", "tsv"]));
+  const remote = async (script) => {
+    for (let attempt = 0; attempt < 6; attempt += 1) {
+      try { return extractRunCommand(await command("az", ["vm", "run-command", "invoke", "--resource-group", resourceGroup, "--name", vm, "--command-id", "RunShellScript", "--scripts", script, "--query", "value[0].message", "--output", "tsv"])); }
+      catch (error) {
+        if (!error.message.includes("Conflict") || attempt === 5) throw error;
+        await new Promise((resolve) => setTimeout(resolve, 10_000));
+      }
+    }
+    throw new Error("Azure Run Command remained busy");
+  };
   const withVault = async (operation) => {
     const ip = await command("curl", ["-fsS", "https://api.ipify.org"]);
     await command("az", ["keyvault", "network-rule", "add", "--name", vault, "--ip-address", `${ip}/32`, "--output", "none"]);
@@ -47,7 +56,7 @@ export function createOperator(environment = process.env) {
       return command(path.join(root, "bin/factory"), [action]);
     },
     capabilities: async () => JSON.parse(await readFile(path.join(root, "config/capabilities.json"), "utf8")),
-    config: () => ({ resourceGroup, vm, namespace, vault }),
+    config: () => ({ resourceGroup, vm, namespace, vault, models: { scout: "GPT-5.4 nano", simpleBuilder: "Kimi K2.7-Code", builder: "GPT-5.5", tester: "GPT-5.4", critical: "GPT-5.6" } }),
     listSecrets: async () => withVault(async () => JSON.parse(await command("az", ["keyvault", "secret", "list", "--vault-name", vault, "--query", "[].{name:name,updated:attributes.updated}", "--output", "json"]))),
     setSecret: async (name, value) => withVault(async () => {
       if (!/^[A-Za-z0-9-]{1,127}$/.test(name) || !value) throw new Error("Valid secret name and value are required");

package/src/project-memory.js

@@ -12,11 +12,19 @@ export class ProjectMemory {
     await appendFile(this.file, `${JSON.stringify({ ...event, recordedAt: new Date().toISOString() })}\n`, { mode: 0o640 });
   }
 
-  async context(repository, limit = 20) {
+  async context(repository, limit = 8) {
     let text;
     try { text = await readFile(this.file, "utf8"); } catch (error) { if (error.code === "ENOENT") return []; throw error; }
     return text.split("\n").filter(Boolean).flatMap((line) => {
       try { const value = JSON.parse(line); return value.repository === repository ? [value] : []; } catch { return []; }
-    }).slice(-limit);
+    }).slice(-limit).map((value) => ({
+      type: value.type,
+      objectiveId: value.objectiveId,
+      objective: String(value.objective ?? "").slice(0, 1000),
+      executiveIntent: String(value.executiveIntent ?? "").slice(0, 1000),
+      pullRequest: value.pullRequest,
+      blockers: (value.blockers ?? []).slice(0, 10).map((item) => String(item).slice(0, 300)),
+      recordedAt: value.recordedAt,
+    }));
   }
 }

package/src/routing.js

@@ -13,7 +13,7 @@ const MODELS = Object.freeze({
   scout: "azureai-textved/factory-gpt-5-4-nano",
   tester: "azureai-responses/gpt-5.4",
   planner: "azureai-textved/gpt-5.6-sol",
-  builder: "azureai-textved/gpt-5.6-sol",
+  builder: "azureai-textved/gpt-5.5",
   debugger: "azureai-textved/gpt-5.6-sol",
   reviewer: "azureai-textved/gpt-5.6-sol",
   security: "azureai-textved/gpt-5.6-sol",

package/src/scanner-suite.js

@@ -26,9 +26,10 @@ const scanners = [
 
 function redact(value) {
   return String(value)
+    .replaceAll(/\u001b\[[0-9;]*m/g, "")
     .replaceAll(/((?:api[_-]?key|token|secret|password)\s*[=:]\s*)\S+/gi, "$1[REDACTED]")
     .replaceAll(/\b[A-Za-z0-9+/_=-]{48,}\b/g, "[REDACTED]")
-    .slice(-20_000);
+    .slice(-6000);
 }
 
 export class ScannerSuite {

package/src/telegram-service.js

@@ -1,13 +1,14 @@
 #!/usr/bin/env node
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { createHash } from "node:crypto";
 import { DefaultAzureCredential } from "@azure/identity";
 import { ServiceBusClient } from "@azure/service-bus";
 import { loadConfig } from "./config.js";
 import { loadRuntimeSecrets } from "./secrets.js";
 import { sendMessage } from "./bus.js";
 import { loadLocalState, loadQueueMetrics } from "./dashboard.js";
-import { isAllowedChat, objectiveFromTelegram, parseTelegramCommand } from "./telegram.js";
+import { formatObjectiveProgress, isAllowedChat, objectiveFromTelegram, parseTelegramCommand } from "./telegram.js";
 import { log } from "./log.js";
 
 const config = loadConfig();
@@ -21,9 +22,16 @@ if (!token || allowed.size === 0) {
 
 const directory = path.join(config.stateDir, "telegram");
 const offsetFile = path.join(directory, "offset");
+const preferencesFile = path.join(directory, "preferences.json");
+const subscriptionsFile = path.join(directory, "subscriptions.json");
 await mkdir(directory, { recursive: true, mode: 0o750 });
 let offset = 0;
 try { offset = Number(await readFile(offsetFile, "utf8")) || 0; } catch (error) { if (error.code !== "ENOENT") throw error; }
+async function loadJson(file) {
+  try { return JSON.parse(await readFile(file, "utf8")); } catch (error) { if (error.code === "ENOENT") return {}; throw error; }
+}
+const preferences = await loadJson(preferencesFile);
+const subscriptions = await loadJson(subscriptionsFile);
 
 const client = new ServiceBusClient(config.serviceBusFqdn, new DefaultAzureCredential());
 const sender = client.createSender(config.controlQueue);
@@ -51,6 +59,12 @@ async function saveOffset(value) {
   await rename(temporary, offsetFile);
 }
 
+async function saveJson(file, value) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  await writeFile(temporary, `${JSON.stringify(value, null, 2)}\n`, { mode: 0o640 });
+  await rename(temporary, file);
+}
+
 async function statusText() {
   const [{ states }, queue] = await Promise.all([loadLocalState(config.stateDir), loadQueueMetrics(config)]);
   const counts = {};
@@ -62,17 +76,52 @@ async function processUpdate(update) {
   const message = update.message;
   if (!message?.text || !isAllowedChat(message.chat?.id, allowed)) return;
   try {
-    const command = parseTelegramCommand(message.text);
-    if (command.type === "help") return reply(message.chat.id, "/submit OWNER/REPO objective\n/goal OWNER/REPO objective\n/loop OWNER/REPO objective\n/status\n/help");
+    const chatId = String(message.chat.id);
+    const command = parseTelegramCommand(message.text, preferences[chatId]?.repository);
+    if (command.type === "help") return reply(message.chat.id, "/repo OWNER/REPO\nPlain text objective\n/submit OWNER/REPO objective\n/goal [OWNER/REPO] objective\n/loop [OWNER/REPO] objective\n/status\n/recent\n/objective ID\n/help");
     if (command.type === "status") return reply(message.chat.id, await statusText());
+    if (command.type === "set_repository") {
+      preferences[chatId] = { repository: command.repository, updatedAt: new Date().toISOString() };
+      await saveJson(preferencesFile, preferences);
+      return reply(message.chat.id, `Default repository set to ${command.repository}. You can now send plain-text objectives.`);
+    }
+    if (command.type === "recent") {
+      const { states } = await loadLocalState(config.stateDir);
+      const text = states.slice(-10).reverse().map((state) => `${state.status ?? "unknown"} — ${state.objective?.id}\n${String(state.objective?.objective ?? "").slice(0, 150)}`).join("\n\n") || "No objectives.";
+      return reply(message.chat.id, text);
+    }
+    if (command.type === "objective") {
+      const state = JSON.parse(await readFile(path.join(config.stateDir, command.objectiveId, "state.json"), "utf8"));
+      return reply(message.chat.id, formatObjectiveProgress(state));
+    }
     const objective = objectiveFromTelegram(update.update_id, command);
     await sendMessage(sender, objective, objective.id);
+    subscriptions[objective.id] = { chatId, lastDigest: "", createdAt: new Date().toISOString() };
+    await saveJson(subscriptionsFile, subscriptions);
     await reply(message.chat.id, `Queued ${objective.id}\n${command.repository}\n${command.objective}`);
   } catch (error) {
     await reply(message.chat.id, `Rejected: ${String(error.message ?? error).slice(0, 500)}`);
   }
 }
 
+async function notifyProgress() {
+  let changed = false;
+  for (const [objectiveId, subscription] of Object.entries(subscriptions)) {
+    let state;
+    try { state = JSON.parse(await readFile(path.join(config.stateDir, objectiveId, "state.json"), "utf8")); }
+    catch (error) { if (error.code === "ENOENT") continue; throw error; }
+    const text = formatObjectiveProgress(state);
+    const digest = createHash("sha256").update(text).digest("hex");
+    if (digest === subscription.lastDigest) continue;
+    await reply(subscription.chatId, text);
+    subscription.lastDigest = digest;
+    subscription.lastStatus = state.status;
+    subscription.notifiedAt = new Date().toISOString();
+    changed = true;
+  }
+  if (changed) await saveJson(subscriptionsFile, subscriptions);
+}
+
 async function shutdown(signal) {
   log("info", "telegram_shutdown", { signal });
   abort.abort();
@@ -91,6 +140,7 @@ while (!abort.signal.aborted) {
       offset = update.update_id + 1;
       await saveOffset(offset);
     }
+    await notifyProgress();
   } catch (error) {
     if (abort.signal.aborted) break;
     log("error", "telegram_poll_failed", { error: String(error.message ?? error).replaceAll(token, "[REDACTED]").slice(0, 1000) });

package/src/telegram.js

@@ -4,18 +4,26 @@ export function isAllowedChat(chatId, allowed) {
   return allowed.size > 0 && allowed.has(String(chatId));
 }
 
-export function parseTelegramCommand(input) {
+export function parseTelegramCommand(input, defaultRepository) {
   const text = String(input ?? "").trim();
   const [rawCommand, repository, ...words] = text.split(/\s+/);
   const command = rawCommand?.split("@")[0];
-  if (["/status", "/help"].includes(command) && !repository) return { type: command.slice(1) };
+  if (!text.startsWith("/") && defaultRepository) {
+    if (text.length > 8000) throw new Error("Objective is too long");
+    return { type: "submit", repository: defaultRepository, objective: text };
+  }
+  if (["/status", "/help", "/recent"].includes(command) && !repository) return { type: command.slice(1) };
+  if (command === "/objective" && /^[A-Za-z0-9_-]{1,64}$/.test(repository ?? "") && words.length === 0) return { type: "objective", objectiveId: repository };
+  if (command === "/repo" && repositoryPattern.test(repository ?? "") && words.length === 0) return { type: "set_repository", repository };
   if (!["/submit", "/goal", "/loop"].includes(command)) throw new Error("Unknown command. Use /help");
-  if (!repositoryPattern.test(repository ?? "")) throw new Error("Repository must be OWNER/REPO");
-  const objective = words.join(" ").trim();
+  const explicitRepository = repositoryPattern.test(repository ?? "");
+  const selectedRepository = explicitRepository ? repository : defaultRepository;
+  if (!repositoryPattern.test(selectedRepository ?? "")) throw new Error("Repository must be OWNER/REPO or configured with /repo");
+  const objective = (explicitRepository ? words : [repository, ...words]).join(" ").trim();
   if (objective.length < 3) throw new Error("Objective is required");
   if (objective.length > 8000) throw new Error("Objective is too long");
   const prefix = command === "/submit" ? "" : `${command} `;
-  return { type: "submit", repository, objective: `${prefix}${objective}` };
+  return { type: "submit", repository: selectedRepository, objective: `${prefix}${objective}` };
 }
 
 export function objectiveFromTelegram(updateId, command, now = new Date()) {
@@ -29,3 +37,19 @@ export function objectiveFromTelegram(updateId, command, now = new Date()) {
     createdAt: now.toISOString(),
   };
 }
+
+export function formatObjectiveProgress(state) {
+  const tasks = state.tasks ?? [];
+  const results = state.results ?? {};
+  const complete = tasks.filter((task) => results[task.id]?.status === "succeeded").length;
+  const lines = [
+    `Factory AI objective ${state.objective?.id ?? "unknown"}`,
+    state.objective?.objective ?? "",
+    `Status: ${state.status ?? "unknown"}`,
+    `${complete}/${tasks.length} tasks complete`,
+  ];
+  for (const task of tasks.slice(0, 20)) lines.push(`${task.role}: ${results[task.id]?.status ?? "blocked"} — ${task.title}`);
+  if (state.failure) lines.push(`Blocker: ${String(state.failure).slice(0, 500)}`);
+  if (state.release?.url) lines.push(`PR: ${state.release.url}`);
+  return lines.join("\n").slice(0, 4000);
+}

package/src/tui.js

@@ -18,6 +18,7 @@ let capabilities;
 let secrets;
 let logs;
 let section = "Overview";
+let refreshing = false;
 
 function status(message, color = colors.muted) {
   footer.setContent(`  {${color}-fg}${message}{/}   {bold}n{/} new   {bold}r{/} refresh   {bold}q{/} quit`);
@@ -32,8 +33,12 @@ function badge(value) {
 function renderOverview() {
   const cost = dashboard?.cost ? `${dashboard.cost.currency} ${dashboard.cost.monthToDate.toFixed(2)}` : "unavailable";
   const counts = Object.entries(dashboard?.summary?.objectives ?? {}).map(([key, value]) => `${key} ${value}`).join("  ") || "none";
+  const modelUsage = Object.values(dashboard?.modelUsage ?? {});
+  const inputTokens = modelUsage.reduce((sum, item) => sum + item.inputTokens, 0);
+  const cachedTokens = modelUsage.reduce((sum, item) => sum + item.cachedInputTokens, 0);
+  const outputTokens = modelUsage.reduce((sum, item) => sum + item.outputTokens, 0);
   const recent = (dashboard?.objectives ?? []).slice(-8).reverse().map((objective) => `  ${badge(objective.status.padEnd(9))}  {bold}${objective.objective}{/}\n             ${objective.repository ?? ""}`).join("\n\n");
-  main.setContent(`{bold}System{/}\n\n  Queue      {#78dba9-fg}${dashboard?.queue?.active ?? 0}{/}\n  Dead letter ${dashboard?.queue?.deadLetter ?? 0}\n  Azure MTD  {#efc46b-fg}${cost}{/}\n  Objectives ${counts}\n\n{bold}Recent objectives{/}\n\n${recent || "  No objectives yet."}`);
+  main.setContent(`{bold}System{/}\n\n  Queue       {#78dba9-fg}${dashboard?.queue?.active ?? 0}{/}\n  Dead letter ${dashboard?.queue?.deadLetter ?? 0}\n  Azure MTD   {#efc46b-fg}${cost}{/}\n  Objectives  ${counts}\n  Tokens      ${inputTokens} in · ${cachedTokens} cached · ${outputTokens} out\n\n{bold}Recent objectives{/}\n\n${recent || "  No objectives yet."}`);
 }
 
 function renderObjectives() {
@@ -60,7 +65,7 @@ function renderCapabilities() {
 
 function renderSettings() {
   const config = operator.config();
-  main.setContent(`{bold}Runtime{/}\n\n  Resource group  ${config.resourceGroup}\n  VM              ${config.vm}\n  Service Bus     ${config.namespace}\n  Key Vault       ${config.vault}\n\n{bold}Model policy{/}\n\n  Scout           GPT-5.4 nano\n  Simple builder  Kimi K2.7-Code\n  Builder         GPT-5.6\n  Tester          GPT-5.4\n  Critical roles  GPT-5.6\n\n{#7f8b99-fg}Run factory setup to change providers or role routes.{/}`);
+  main.setContent(`{bold}Runtime{/}\n\n  Resource group  ${config.resourceGroup}\n  VM              ${config.vm}\n  Service Bus     ${config.namespace}\n  Key Vault       ${config.vault}\n\n{bold}Model policy{/}\n\n  Scout           GPT-5.4 nano\n  Simple builder  Kimi K2.7-Code\n  Builder         GPT-5.5\n  Tester          GPT-5.4\n  Critical roles  GPT-5.6\n\n{#7f8b99-fg}Run factory setup to change providers or role routes.{/}`);
 }
 
 function render() {
@@ -77,6 +82,8 @@ function render() {
 }
 
 async function refresh() {
+  if (refreshing) return;
+  refreshing = true;
   status("Refreshing...");
   try {
     dashboard = await operator.dashboard();
@@ -86,6 +93,7 @@ async function refresh() {
     render();
     status(`Updated ${new Date().toLocaleTimeString()}`);
   } catch (error) { status(error.message, colors.danger); }
+  finally { refreshing = false; }
 }
 
 function ask(label, { secret = false } = {}) {

package/src/updater.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { readFile } from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+
+function parts(value) {
+  if (!/^\d+\.\d+\.\d+$/.test(value)) throw new Error(`Unsupported version: ${value}`);
+  return value.split(".").map(Number);
+}
+
+export function compareVersions(left, right) {
+  const a = parts(left);
+  const b = parts(right);
+  for (let index = 0; index < 3; index += 1) {
+    if (a[index] !== b[index]) return a[index] > b[index] ? 1 : -1;
+  }
+  return 0;
+}
+
+export function shouldAutoUpdate(current, latest) {
+  const currentParts = parts(current);
+  const latestParts = parts(latest);
+  return currentParts[0] === latestParts[0] && compareVersions(latest, current) > 0;
+}
+
+async function main() {
+  const packageFile = process.env.FACTORY_PACKAGE_FILE ?? "/opt/agent-factory/app/package.json";
+  const current = JSON.parse(await readFile(packageFile, "utf8")).version;
+  const response = await fetch("https://registry.npmjs.org/factory-ai/latest", { signal: AbortSignal.timeout(30_000) });
+  if (!response.ok) throw new Error(`npm registry HTTP ${response.status}`);
+  const latestPackage = await response.json();
+  process.stdout.write(`${JSON.stringify({
+    current,
+    latest: latestPackage.version,
+    gitHead: latestPackage.gitHead,
+    updateAvailable: shouldAutoUpdate(current, latestPackage.version),
+  })}\n`);
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) main().catch((error) => {
+  process.stderr.write(`${error.message}\n`);
+  process.exitCode = 1;
+});

package/src/validation.js

@@ -36,6 +36,16 @@ const taskResultSchema = z.object({
   checks: z.array(z.string().trim().min(1).max(1000)).max(50),
   risks: z.array(z.string().trim().min(1).max(1000)).max(50),
   approval: z.enum(["approved", "changes_requested", "not_applicable"]),
+  telemetry: z.object({
+    model: z.string().min(1).max(300),
+    steps: z.number().int().nonnegative(),
+    durationMs: z.number().int().nonnegative(),
+    usage: z.object({
+      inputTokens: z.number().int().nonnegative().default(0),
+      cachedInputTokens: z.number().int().nonnegative().default(0),
+      outputTokens: z.number().int().nonnegative().default(0),
+    }),
+  }).optional(),
 }).strict();
 
 export const workMessageSchema = z.object({

package/src/workspace-tools.js

@@ -47,17 +47,25 @@ export function createWorkspaceTools(rootInput, { execute = run } = {}) {
   const root = realpathSync(path.resolve(rootInput));
   return {
     read_file: {
-      description: "Read a UTF-8 file inside the assigned workspace.",
+      description: "Read a bounded UTF-8 line range inside the assigned workspace. Use offsetLine/limitLines instead of rereading large files.",
       parameters: {
         type: "object",
-        properties: { path: { type: "string" } },
+        properties: {
+          path: { type: "string" },
+          offsetLine: { type: "integer", minimum: 1 },
+          limitLines: { type: "integer", minimum: 1, maximum: 2000 },
+        },
         required: ["path"],
         additionalProperties: false,
       },
-      execute: async ({ path: requested }) => {
+      execute: async ({ path: requested, offsetLine = 1, limitLines = 400 }) => {
         const value = await readFile(await existingPath(root, requested), "utf8");
-        if (Buffer.byteLength(value) > 512_000) throw new Error("File exceeds 512000 bytes");
-        return value;
+        const lines = value.split("\n");
+        const start = offsetLine - 1;
+        let output = lines.slice(start, start + limitLines).join("\n");
+        if (start + limitLines < lines.length) output += `\n[TRUNCATED: ${lines.length - start - limitLines} more lines; request the next range]`;
+        if (Buffer.byteLength(output) > 256_000) output = `${output.slice(0, 256_000)}\n[TRUNCATED: byte limit]`;
+        return output;
       },
     },
     write_file: {
@@ -81,14 +89,14 @@ export function createWorkspaceTools(rootInput, { execute = run } = {}) {
       description: "List files recursively inside the assigned workspace.",
       parameters: {
         type: "object",
-        properties: { path: { type: "string" } },
+        properties: { path: { type: "string" }, limit: { type: "integer", minimum: 1, maximum: 2000 } },
         required: ["path"],
         additionalProperties: false,
       },
-      execute: async ({ path: requested }) => {
+      execute: async ({ path: requested, limit = 500 }) => {
         const directory = await existingPath(root, requested);
         const output = [];
-        await walk(directory, root, output, 2000);
+        await walk(directory, root, output, limit);
         return JSON.stringify(output);
       },
     },
@@ -110,11 +118,12 @@ export function createWorkspaceTools(rootInput, { execute = run } = {}) {
         const result = await execute(command, args, {
           cwd: root,
           timeoutMs: 900_000,
-          maxOutputBytes: 2_000_000,
+          maxOutputBytes: 500_000,
           inheritEnv: false,
           env: { PATH: process.env.PATH, HOME: "/tmp/agent-home", CI: "true", NO_COLOR: "1" },
         });
-        return `${result.stdout}${result.stderr ? `\nSTDERR:\n${result.stderr}` : ""}`.slice(-2_000_000);
+        const output = `${result.stdout}${result.stderr ? `\nSTDERR:\n${result.stderr}` : ""}`;
+        return output.length > 120_000 ? `[TRUNCATED: showing final 120000 characters]\n${output.slice(-120_000)}` : output;
       },
     },
   };