chore: integrate 10 pending PRs (#114 #115 #150 #153 #154 #156 #158 #164 #166 #176)

src/always-on/config/parseAlwaysOnConfig.ts

@@ -23,6 +23,7 @@ export type AlwaysOnWorkspaceConfig = {
   snapshotBaseDir?: string;
   snapshotMaxBytes: number;
   gitLfs: boolean;
+  maxPlansPerCycle: number;
 };
 
 export type AlwaysOnExecutionConfig = {
@@ -78,6 +79,7 @@ export function defaultAlwaysOnConfig(): AlwaysOnConfig {
     workspace: {
       snapshotMaxBytes: DEFAULT_SNAPSHOT_MAX_BYTES,
       gitLfs: false,
+      maxPlansPerCycle: 3,
     },
     execution: {
       maxTurns: 30,
@@ -340,6 +342,12 @@ function parseWorkspace(
     diagnostics,
   );
   target.gitLfs = booleanField(raw, "gitLfs", target.gitLfs);
+  target.maxPlansPerCycle = positiveInteger(
+    raw.maxPlansPerCycle,
+    target.maxPlansPerCycle,
+    "alwaysOn.workspace.maxPlansPerCycle",
+    diagnostics,
+  );
 }
 
 function parseExecution(

src/always-on/index.ts

@@ -157,7 +157,7 @@ export {
   type WebPlanContextRefs,
   type WebPlanStatus,
 } from "./web/DiscoveryPlanStatus.js";
-export { DiscoveryPlanService, normalizeDiscoveryPlanRecord, type DiscoveryPlanServiceDeps } from "./web/DiscoveryPlanService.js";
+export { DiscoveryPlanService, normalizeDiscoveryPlanRecord, type DiscoveryPlanServiceDeps, type StateManager } from "./web/DiscoveryPlanService.js";
 export { buildDiscoveryContext, type DiscoveryContextDeps } from "./web/DiscoveryPlanContext.js";
 export { AlwaysOnRunHistoryService, type AlwaysOnRunHistoryServiceDeps, type RunHistoryEntry, type RunHistoryDetailEntry } from "./web/AlwaysOnRunHistoryService.js";
 export { GitWorktreeProvider, type GitWorktreeProviderOptions } from "./workspace/GitWorktreeProvider.js";

src/always-on/protocol/types.ts

@@ -142,7 +142,8 @@ export type GateBlockReason =
   | "recent_user_msg"
   | "cooldown"
   | "daily_budget"
-  | "lock_busy";
+  | "lock_busy"
+  | "cycle_full";
 
 export type GateResult =
   | { ok: true; lease?: AlwaysOnChannelLease }

src/always-on/runtime/AlwaysOnRuntime.ts

@@ -216,6 +216,7 @@ export class AlwaysOnRuntime {
       projectKey: this.projectKey,
       paths: this.paths,
       stateStore: this.stateStore,
+      cycleStore: this.cycleStore,
       leases: this.leases,
       fire: this.fire,
       uuid: this.uuid,

src/always-on/runtime/DiscoveryFire.ts

@@ -5,7 +5,7 @@ import type { Gateway, GatewayChannelKey, GatewayEvent } from "../../gateway/ind
 import { getPilotProjectChatDir } from "../../pilot/paths.js";
 import { buildChatDigest } from "../context/ChatDigestBuilder.js";
 import type { AlwaysOnConfig } from "../config/parseAlwaysOnConfig.js";
-import { buildFallbackReport, type ReportMetadata } from "../contracts/ReportContract.js";
+import { buildFallbackReport, parseReportMarkdown, type ReportMetadata } from "../contracts/ReportContract.js";
 import { AlwaysOnError } from "../protocol/errors.js";
 import type {
   AlwaysOnDiscoveryOutcome,
@@ -458,24 +458,44 @@ export class DiscoveryFire {
     };
     this.deps.runContexts.register(reportCtx);
 
+    let reportEvents: GatewayEvent[] = [];
     let reportError: { code?: string; message: string } | undefined;
     try {
-      const events = await this.drainTurn({
+      reportEvents = await this.drainTurn({
         sessionKey: reportSessionKey,
         channelKey: REPORT_CHANNEL,
         runId: `${runId}.report`,
         message: buildReportPrompt({ plan: planRecord, planMarkdown, workspaceCwd: workspace.cwd, workspaceStrategy: workspace.strategy, language: this.deps.config.language }),
         mode: "bypassPermissions",
         persistEvents: true,
       });
-      reportError = pickFirstError(events);
+      reportError = pickFirstError(reportEvents);
     } finally {
       this.deps.runContexts.unregister(reportSessionKey);
       this.deps.sessionOverrides.delete(reportSessionKey);
       await this.deps.gateway.closeSession({ sessionKey: reportSessionKey, reason: "always-on/done" }).catch(() => undefined);
     }
 
     const finishedAt = this.deps.now();
+
+    if (!reportCtx.report && !reportError) {
+      const assistantText = extractAssistantText(reportEvents);
+      if (assistantText) {
+        const metadata: ReportMetadata = {
+          runId,
+          planId,
+          startedAt: startedAt.toISOString(),
+          finishedAt: finishedAt.toISOString(),
+          outcome: "executed",
+          workspaceStrategy: workspace.strategy === "git-worktree" ? "git-worktree" : "snapshot-copy",
+          workspaceHandle: workspace.cwd,
+        };
+        const parsed = parseReportMarkdown(assistantText, metadata);
+        const filePath = await this.deps.reportStore.writeReport(runId, parsed.rawContent);
+        reportCtx.report = { markdown: parsed.rawContent, filePath, finishedAt };
+      }
+    }
+
     const outcome: AlwaysOnDiscoveryOutcome = reportCtx.report && !reportError ? "executed" : "failed";
 
     if (reportCtx.report && !reportError) {
@@ -801,9 +821,10 @@ export class DiscoveryFire {
     };
     this.deps.runContexts.register(reportCtx);
 
+    let reportEvents: GatewayEvent[] = [];
     let reportError: { code?: string; message: string } | undefined;
     try {
-      const events = await this.drainTurn({
+      reportEvents = await this.drainTurn({
         sessionKey: reportSessionKey,
         channelKey: REPORT_CHANNEL,
         runId: `${runId}.report`,
@@ -817,7 +838,7 @@ export class DiscoveryFire {
         mode: "bypassPermissions",
         persistEvents: true,
       });
-      reportError = pickFirstError(events);
+      reportError = pickFirstError(reportEvents);
     } finally {
       this.deps.runContexts.unregister(reportSessionKey);
       this.deps.sessionOverrides.delete(reportSessionKey);
@@ -827,6 +848,25 @@ export class DiscoveryFire {
     }
 
     const finishedAt = this.deps.now();
+
+    if (!reportCtx.report && !reportError) {
+      const assistantText = extractAssistantText(reportEvents);
+      if (assistantText) {
+        const metadata: ReportMetadata = {
+          runId,
+          planId: planRecord.id,
+          startedAt: startedAt.toISOString(),
+          finishedAt: finishedAt.toISOString(),
+          outcome: "executed",
+          workspaceStrategy: workspace.strategy === "git-worktree" ? "git-worktree" : "snapshot-copy",
+          workspaceHandle: workspace.cwd,
+        };
+        const parsed = parseReportMarkdown(assistantText, metadata);
+        const filePath = await this.deps.reportStore.writeReport(runId, parsed.rawContent);
+        reportCtx.report = { markdown: parsed.rawContent, filePath, finishedAt };
+      }
+    }
+
     const outcome: AlwaysOnDiscoveryOutcome = reportCtx.report && !reportError ? "executed" : "failed";
 
     if (reportCtx.report && !reportError) {
@@ -1116,3 +1156,13 @@ function pickFirstError(events: GatewayEvent[]): { code?: string; message: strin
   }
   return undefined;
 }
+
+function extractAssistantText(events: GatewayEvent[]): string {
+  let text = "";
+  for (const event of events) {
+    if (event.type === "assistant_text_delta") {
+      text += event.text;
+    }
+  }
+  return text.trim();
+}

src/always-on/runtime/DiscoveryScheduler.ts

@@ -4,6 +4,7 @@ import { AlwaysOnError } from "../protocol/errors.js";
 import type { GateBlockReason } from "../protocol/types.js";
 import type { AlwaysOnPaths } from "../storage/AlwaysOnPaths.js";
 import { DiscoveryStateStore } from "../storage/DiscoveryStateStore.js";
+import { WorkCycleStore } from "../storage/WorkCycleStore.js";
 import type { ChannelLeaseRegistry } from "./ChannelLeaseRegistry.js";
 import {
   acquireDiscoveryLock,
@@ -23,6 +24,7 @@ export type DiscoverySchedulerDependencies = {
   projectKey: string;
   paths: AlwaysOnPaths;
   stateStore: DiscoveryStateStore;
+  cycleStore: WorkCycleStore;
   leases: ChannelLeaseRegistry;
   fire: DiscoveryFire;
   uuid: () => string;
@@ -113,6 +115,18 @@ export class DiscoveryScheduler {
       return { outcome: "blocked", reason: evaluation.reason };
     }
 
+    if (state.activeWorkCycleId) {
+      const activeCycle = await this.deps.cycleStore.getRecord(state.activeWorkCycleId);
+      if (
+        activeCycle &&
+        activeCycle.status === "active" &&
+        activeCycle.planIds.length >= this.deps.config.workspace.maxPlansPerCycle
+      ) {
+        this.deps.logger.info("always-on gate blocked", { reason: "cycle_full" });
+        return { outcome: "blocked", reason: "cycle_full" as GateBlockReason };
+      }
+    }
+
     const runId = this.deps.uuid();
     const startedAt = this.deps.now();
 

src/always-on/web/DiscoveryPlanService.ts

@@ -103,6 +103,10 @@ export type WorkspaceManager = {
   ): Promise<void>;
 };
 
+export type StateManager = {
+  clearActiveWorkCycleId(projectRoot: string): Promise<void>;
+};
+
 export type DiscoveryPlanServiceDeps = {
   pilotHome: string;
   createProjectId: (projectRoot: string) => string;
@@ -111,6 +115,7 @@ export type DiscoveryPlanServiceDeps = {
   activity: SessionActivityChecker;
   events: RunEventSink;
   workspace?: WorkspaceManager;
+  state?: StateManager;
 };
 
 // ---------------------------------------------------------------------------
@@ -395,6 +400,14 @@ export class DiscoveryPlanService {
     }
     await writePlanStore(projectDir, store);
 
+    if (this.deps.state) {
+      try {
+        await this.deps.state.clearActiveWorkCycleId(projectRoot);
+      } catch {
+        // Best effort — state cleanup should not block archive.
+      }
+    }
+
     return { archived: true };
   }
 
@@ -500,6 +513,14 @@ export class DiscoveryPlanService {
           }
         }
         await writePlanStore(projectDir, store);
+
+        if (this.deps.state) {
+          try {
+            await this.deps.state.clearActiveWorkCycleId(projectRoot);
+          } catch {
+            // Best effort — state cleanup should not block apply finalization.
+          }
+        }
       }
     }
 

src/cli/createLocalGateway.ts

@@ -760,7 +760,7 @@ class ProjectRuntimeRegistry {
             sanitizeSessionIdForPath(context.sessionKey),
           );
           mkdirSyncFs(outDir, { recursive: true });
-          return { ...spec, args: [...(spec.args ?? []), `--output-dir=${outDir}`] };
+          return { ...spec, cwd: outDir, args: [...(spec.args ?? []), `--output-dir=${outDir}`] };
         }
         return spec;
       });

src/cli/pilotdeck.ts

@@ -13,11 +13,11 @@ import {
 import { loadPilotConfig, resolvePilotHome } from "../pilot/index.js";
 import { createLocalGateway } from "./createLocalGateway.js";
 import { startPilotDeckServer } from "./pilotdeckServer.js";
-import { installGlobalProxy } from "./proxy.js";
+import { installGlobalProxy, reinstallGlobalProxy } from "./proxy.js";
 import { createShutdownAndExit } from "./shutdownCoordinator.js";
 import { createTelemetryCollector } from "../telemetry/index.js";
 
-installGlobalProxy();
+await installGlobalProxy();
 
 async function main(argv = process.argv.slice(2)): Promise<void> {
   const command = argv[0];
@@ -26,7 +26,16 @@ async function main(argv = process.argv.slice(2)): Promise<void> {
     const env = process.env;
     const pilotHome = resolvePilotHome(env);
     const snapshot = loadPilotConfig({ projectRoot, env });
-    const telemetry = createTelemetryCollector({ env, pilotHome });
+    const telemetry = createTelemetryCollector({
+      env, pilotHome,
+      enabled: snapshot.config.telemetry?.enabled,
+    });
+
+    // Apply proxy from config (env-based proxy from top-level installGlobalProxy
+    // takes precedence; this fills in when only pilotdeck.yaml has a proxy).
+    if (snapshot.config.proxy?.url) {
+      await installGlobalProxy(snapshot.config.proxy.url);
+    }
 
     let alwaysOn: AlwaysOnManager | undefined;
     let cron: CronRuntime | undefined;
@@ -128,8 +137,19 @@ async function main(argv = process.argv.slice(2)): Promise<void> {
     let reloadChain = Promise.resolve();
 
     configStore.subscribe((event) => {
+      if (event.changedPaths.some((p) => p.startsWith("telemetry."))) {
+        telemetry.setEnabled(event.nextSnapshot.config.telemetry?.enabled ?? false);
+      }
+
       const aoChanged = event.changedPaths.some((p) => p.startsWith("alwaysOn."));
       const cronChanged = event.changedPaths.some((p) => p.startsWith("cron."));
+      const proxyChanged = event.changedPaths.some((p) => p.startsWith("proxy.") || p === "proxy");
+
+      if (proxyChanged) {
+        const proxyConfig = event.nextSnapshot.config.proxy;
+        void reinstallGlobalProxy(proxyConfig?.url, proxyConfig?.noProxy);
+      }
+
       if (!aoChanged && !cronChanged) return;
 
       reloadChain = reloadChain