newo 3.7.1 → 3.7.2

package/dist/sync/flow-metadata.js

@@ -0,0 +1,283 @@
+import { listFlowEvents, listFlowStates, createFlowEvent, updateFlowEvent, deleteFlowEvent, createFlowState, updateFlowState, deleteFlowState, updateFlow } from '../api.js';
+export function emptyFlowSyncCounts() {
+    return {
+        flowsUpdated: 0,
+        eventsCreated: 0,
+        eventsUpdated: 0,
+        eventsDeleted: 0,
+        statesCreated: 0,
+        statesUpdated: 0,
+        statesDeleted: 0,
+        errors: []
+    };
+}
+/**
+ * True when remote FlowEvent fields differ from what the local metadata says.
+ * We only compare semantic fields the platform stores - `id` is platform-owned.
+ */
+export function flowEventDiffers(local, remote) {
+    return (normalizeStr(local.description) !== normalizeStr(remote.description) ||
+        normalizeStr(local.skill_selector) !== normalizeStr(remote.skill_selector) ||
+        normalizeStr(local.skill_idn) !== normalizeStr(remote.skill_idn) ||
+        normalizeStr(local.state_idn) !== normalizeStr(remote.state_idn) ||
+        normalizeStr(local.interrupt_mode) !== normalizeStr(remote.interrupt_mode) ||
+        normalizeStr(local.integration_idn) !== normalizeStr(remote.integration_idn) ||
+        normalizeStr(local.connector_idn) !== normalizeStr(remote.connector_idn));
+}
+export function flowStateDiffers(local, remote) {
+    return (normalizeStr(local.title) !== normalizeStr(remote.title) ||
+        normalizeStr(local.default_value) !== normalizeStr(remote.default_value) ||
+        normalizeStr(local.scope) !== normalizeStr(remote.scope));
+}
+/**
+ * Normalizes nullable/undefined string fields so YAML round-trips don't
+ * register as differences. `null`, `undefined`, and missing all collapse to ''.
+ */
+function normalizeStr(value) {
+    if (value === null || value === undefined)
+        return '';
+    return String(value);
+}
+function buildEventCreateRequest(local) {
+    return {
+        idn: local.idn,
+        description: local.description ?? '',
+        skill_selector: local.skill_selector,
+        ...(local.skill_idn != null ? { skill_idn: local.skill_idn } : {}),
+        state_idn: local.state_idn ?? null,
+        interrupt_mode: local.interrupt_mode,
+        integration_idn: local.integration_idn ?? '',
+        connector_idn: local.connector_idn ?? ''
+    };
+}
+function buildEventUpdateRequest(local) {
+    return {
+        idn: local.idn,
+        description: local.description ?? '',
+        skill_selector: local.skill_selector,
+        skill_idn: local.skill_idn ?? null,
+        state_idn: local.state_idn ?? null,
+        interrupt_mode: local.interrupt_mode,
+        integration_idn: local.integration_idn ?? null,
+        connector_idn: local.connector_idn ?? null
+    };
+}
+function buildStateCreateRequest(local) {
+    const req = {
+        title: local.title || local.idn,
+        idn: local.idn,
+        scope: local.scope
+    };
+    if (local.default_value != null) {
+        req.default_value = local.default_value;
+    }
+    return req;
+}
+function buildStateUpdateRequest(local) {
+    const req = {
+        title: local.title || local.idn,
+        idn: local.idn,
+        scope: local.scope
+    };
+    if (local.default_value != null) {
+        req.default_value = local.default_value;
+    }
+    return req;
+}
+function shouldUpdateFlow(local, remote) {
+    return (normalizeStr(local.title) !== normalizeStr(remote.title) ||
+        normalizeStr(local.description) !== normalizeStr(remote.description) ||
+        normalizeStr(local.default_runner_type) !== normalizeStr(remote.default_runner_type));
+}
+/**
+ * Reconcile one flow's metadata with the platform.
+ *
+ * @param client          authenticated Axios client
+ * @param flowId          platform flow ID (UUID)
+ * @param local           parsed FlowMetadata from the customer's local YAML
+ * @param remoteFlow      flow data fetched from GET /flows/{id} - if null,
+ *                        flow-level updates are skipped (still syncs children).
+ *                        Pass null when caller already knows the GET endpoint
+ *                        will 404 (e.g. legacy data) or wants children-only.
+ * @param verbose         when true, emits per-operation log lines
+ * @param counts          shared counter mutated in place across multiple flows
+ */
+export async function syncFlowMetadata(client, flowId, local, remoteFlow, verbose, counts) {
+    // 1. Flow-level fields (title, description, runner type)
+    if (remoteFlow && shouldUpdateFlow(local, remoteFlow)) {
+        try {
+            const updateRequest = {
+                idn: local.idn,
+                title: local.title,
+                description: local.description ?? '',
+                default_runner_type: local.default_runner_type,
+                default_model: local.default_model
+            };
+            await updateFlow(client, flowId, updateRequest);
+            counts.flowsUpdated++;
+            if (verbose) {
+                console.log(`    ↑ Updated flow metadata: ${local.idn} (title: "${remoteFlow.title}" → "${local.title}")`);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            counts.errors.push(`Failed to update flow ${local.idn}: ${msg}`);
+            console.error(`    ❌ Failed to update flow ${local.idn}: ${msg}`);
+        }
+    }
+    // 2. Events
+    let remoteEvents = [];
+    try {
+        remoteEvents = await listFlowEvents(client, flowId);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        counts.errors.push(`Failed to list events for flow ${local.idn}: ${msg}`);
+        return;
+    }
+    const localEvents = local.events ?? [];
+    const remoteByIdn = new Map(remoteEvents.map(e => [e.idn, e]));
+    const localByIdn = new Map(localEvents.map(e => [e.idn, e]));
+    // Create or update events present locally
+    for (const localEvent of localEvents) {
+        const remote = remoteByIdn.get(localEvent.idn);
+        if (!remote) {
+            // Create
+            try {
+                await createFlowEvent(client, flowId, buildEventCreateRequest(localEvent));
+                counts.eventsCreated++;
+                if (verbose)
+                    console.log(`    ↑ Created event: ${local.idn}/${localEvent.idn}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                counts.errors.push(`Failed to create event ${localEvent.idn} in flow ${local.idn}: ${msg}`);
+                console.error(`    ❌ Failed to create event ${localEvent.idn}: ${msg}`);
+            }
+        }
+        else if (flowEventDiffers(localEvent, remote)) {
+            try {
+                await updateFlowEvent(client, remote.id, buildEventUpdateRequest(localEvent));
+                counts.eventsUpdated++;
+                if (verbose)
+                    console.log(`    ↑ Updated event: ${local.idn}/${localEvent.idn}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                counts.errors.push(`Failed to update event ${localEvent.idn} in flow ${local.idn}: ${msg}`);
+                console.error(`    ❌ Failed to update event ${localEvent.idn}: ${msg}`);
+            }
+        }
+    }
+    // Delete events present remotely but missing locally
+    for (const remoteEvent of remoteEvents) {
+        if (!localByIdn.has(remoteEvent.idn)) {
+            try {
+                await deleteFlowEvent(client, remoteEvent.id);
+                counts.eventsDeleted++;
+                if (verbose)
+                    console.log(`    ↑ Deleted event: ${local.idn}/${remoteEvent.idn}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                counts.errors.push(`Failed to delete event ${remoteEvent.idn} in flow ${local.idn}: ${msg}`);
+                console.error(`    ❌ Failed to delete event ${remoteEvent.idn}: ${msg}`);
+            }
+        }
+    }
+    // 3. State fields
+    let remoteStates = [];
+    try {
+        remoteStates = await listFlowStates(client, flowId);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        counts.errors.push(`Failed to list states for flow ${local.idn}: ${msg}`);
+        return;
+    }
+    const localStates = local.state_fields ?? [];
+    const remoteStatesByIdn = new Map(remoteStates.map(s => [s.idn, s]));
+    const localStatesByIdn = new Map(localStates.map(s => [s.idn, s]));
+    for (const localState of localStates) {
+        const remote = remoteStatesByIdn.get(localState.idn);
+        if (!remote) {
+            try {
+                await createFlowState(client, flowId, buildStateCreateRequest(localState));
+                counts.statesCreated++;
+                if (verbose)
+                    console.log(`    ↑ Created state: ${local.idn}/${localState.idn}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                counts.errors.push(`Failed to create state ${localState.idn} in flow ${local.idn}: ${msg}`);
+                console.error(`    ❌ Failed to create state ${localState.idn}: ${msg}`);
+            }
+        }
+        else if (flowStateDiffers(localState, remote)) {
+            try {
+                await updateFlowState(client, remote.id, buildStateUpdateRequest(localState));
+                counts.statesUpdated++;
+                if (verbose)
+                    console.log(`    ↑ Updated state: ${local.idn}/${localState.idn}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                counts.errors.push(`Failed to update state ${localState.idn} in flow ${local.idn}: ${msg}`);
+                console.error(`    ❌ Failed to update state ${localState.idn}: ${msg}`);
+            }
+        }
+    }
+    for (const remoteState of remoteStates) {
+        if (!localStatesByIdn.has(remoteState.idn)) {
+            try {
+                await deleteFlowState(client, remoteState.id);
+                counts.statesDeleted++;
+                if (verbose)
+                    console.log(`    ↑ Deleted state: ${local.idn}/${remoteState.idn}`);
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                counts.errors.push(`Failed to delete state ${remoteState.idn} in flow ${local.idn}: ${msg}`);
+                console.error(`    ❌ Failed to delete state ${remoteState.idn}: ${msg}`);
+            }
+        }
+    }
+}
+/**
+ * Combined count of operations across all categories.
+ */
+export function totalFlowSyncOps(counts) {
+    return (counts.flowsUpdated +
+        counts.eventsCreated + counts.eventsUpdated + counts.eventsDeleted +
+        counts.statesCreated + counts.statesUpdated + counts.statesDeleted);
+}
+/**
+ * Human-readable summary line for the push report.
+ */
+export function describeFlowSyncCounts(counts) {
+    const parts = [];
+    if (counts.flowsUpdated)
+        parts.push(`${counts.flowsUpdated} flow(s)`);
+    if (counts.eventsCreated || counts.eventsUpdated || counts.eventsDeleted) {
+        const eventOps = [];
+        if (counts.eventsCreated)
+            eventOps.push(`+${counts.eventsCreated}`);
+        if (counts.eventsUpdated)
+            eventOps.push(`~${counts.eventsUpdated}`);
+        if (counts.eventsDeleted)
+            eventOps.push(`-${counts.eventsDeleted}`);
+        parts.push(`events ${eventOps.join('/')}`);
+    }
+    if (counts.statesCreated || counts.statesUpdated || counts.statesDeleted) {
+        const stateOps = [];
+        if (counts.statesCreated)
+            stateOps.push(`+${counts.statesCreated}`);
+        if (counts.statesUpdated)
+            stateOps.push(`~${counts.statesUpdated}`);
+        if (counts.statesDeleted)
+            stateOps.push(`-${counts.statesDeleted}`);
+        parts.push(`states ${stateOps.join('/')}`);
+    }
+    return parts.join(', ');
+}
+//# sourceMappingURL=flow-metadata.js.map

package/dist/sync/push.js

@@ -1,8 +1,8 @@
 /**
  * Push operations for changed files
  */
-import { updateSkill, createAgent, createFlow, createSkill, publishFlow } from '../api.js';
-import { ensureState, mapPath, skillMetadataPath, projectDir, agentMetadataPath } from '../fsutil.js';
+import { updateSkill, createAgent, createFlow, createSkill, publishFlow, getFlow } from '../api.js';
+import { ensureState, mapPath, skillMetadataPath, projectDir, agentMetadataPath, flowMetadataPath } from '../fsutil.js';
 import { validateSkillFolder, getSingleSkillFile, getExtensionForRunner } from './skill-files.js';
 import fs from 'fs-extra';
 import { sha256, loadHashes, saveHashes } from '../hash.js';
@@ -11,6 +11,7 @@ import { generateFlowsYaml } from './metadata.js';
 import { isProjectMap, isLegacyProjectMap } from './projects.js';
 import { flowsYamlPath } from '../fsutil.js';
 import { pushAllProjectAttributes } from './attributes.js';
+import { syncFlowMetadata, emptyFlowSyncCounts, totalFlowSyncOps, describeFlowSyncCounts } from './flow-metadata.js';
 /**
  * Scan filesystem for local-only entities not in the project map yet
  */
@@ -444,6 +445,68 @@ export async function pushChanged(client, customer, verbose = false, shouldPubli
             }
         }
     }
+    // Sync flow metadata (title, events, state_fields) for any flow whose
+    // metadata.yaml hash has changed. This closes the loop on GH issue #3:
+    // previously push only updated skill scripts, leaving local edits to
+    // flow events and title silently un-synced.
+    const flowSyncCounts = emptyFlowSyncCounts();
+    for (const [projectIdn, projectData] of Object.entries(projects)) {
+        for (const [agentIdn, agentObj] of Object.entries(projectData.agents)) {
+            for (const [flowIdn, flowObj] of Object.entries(agentObj.flows)) {
+                if (!flowObj.id)
+                    continue;
+                const metaPath = flowMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn);
+                if (!(await fs.pathExists(metaPath)))
+                    continue;
+                const metaContent = await fs.readFile(metaPath, 'utf8');
+                const metaHash = sha256(metaContent);
+                const oldHash = hashes[metaPath];
+                if (oldHash === metaHash) {
+                    if (verbose)
+                        console.log(`    ✓ Flow metadata unchanged: ${flowIdn}`);
+                    continue;
+                }
+                if (verbose)
+                    console.log(`    🔄 Flow metadata changed, syncing: ${agentIdn}/${flowIdn}`);
+                let localFlow;
+                try {
+                    localFlow = yaml.load(metaContent);
+                }
+                catch (error) {
+                    console.error(`❌ Failed to parse flow metadata for ${flowIdn}: ${error instanceof Error ? error.message : String(error)}`);
+                    continue;
+                }
+                let remoteFlow = null;
+                try {
+                    remoteFlow = await getFlow(client, flowObj.id);
+                }
+                catch (error) {
+                    // 404 means the flow ID is stale; skip flow-level update but still
+                    // try to sync children since list endpoints may still work.
+                    if (verbose) {
+                        console.log(`    ⚠️  Could not GET flow ${flowIdn}: ${error.response?.status ?? error.message}`);
+                    }
+                }
+                const opsBefore = totalFlowSyncOps(flowSyncCounts);
+                await syncFlowMetadata(client, flowObj.id, localFlow, remoteFlow, verbose, flowSyncCounts);
+                const opsAfter = totalFlowSyncOps(flowSyncCounts);
+                if (opsAfter > opsBefore) {
+                    pushed += (opsAfter - opsBefore);
+                    metadataChanged = true;
+                }
+                // Hash is updated regardless of whether ops happened, so we don't
+                // re-scan the same untouched flow on the next push.
+                newHashes[metaPath] = metaHash;
+            }
+        }
+    }
+    const totalFlowOps = totalFlowSyncOps(flowSyncCounts);
+    if (totalFlowOps > 0) {
+        console.log(`↑ Flow metadata synced: ${describeFlowSyncCounts(flowSyncCounts)}`);
+    }
+    if (flowSyncCounts.errors.length > 0) {
+        console.warn(`⚠️  ${flowSyncCounts.errors.length} flow-metadata error(s) during push.`);
+    }
     if (verbose)
         console.log(`🔄 Scanned ${scanned} files, found ${pushed} changes`);
     // Push project attributes for all projects

package/dist/types.d.ts

@@ -441,6 +441,22 @@ export interface CreateFlowEventRequest {
 export interface CreateFlowEventResponse {
     id: string;
 }
+/**
+ * Payload for PATCH /api/v1/designer/flows/events/{eventId}
+ *
+ * Required fields per probe testing: idn, skill_selector, interrupt_mode.
+ * Sending the full event body is the platform's expected shape.
+ */
+export interface UpdateFlowEventRequest {
+    idn: string;
+    description?: string | null;
+    skill_selector: string;
+    skill_idn?: string | null;
+    state_idn?: string | null;
+    interrupt_mode: string;
+    integration_idn?: string | null;
+    connector_idn?: string | null;
+}
 export interface CreateFlowStateRequest {
     title: string;
     idn: string;
@@ -450,6 +466,27 @@ export interface CreateFlowStateRequest {
 export interface CreateFlowStateResponse {
     id: string;
 }
+/**
+ * Payload for PUT /api/v1/designer/flows/states/{stateId}
+ */
+export interface UpdateFlowStateRequest {
+    title: string;
+    idn: string;
+    default_value?: string;
+    scope: string;
+}
+/**
+ * Payload for PATCH /api/v1/designer/flows/{flowId}
+ *
+ * Empty body returns 500; the platform requires the full descriptor.
+ */
+export interface UpdateFlowRequest {
+    idn: string;
+    title: string;
+    description?: string;
+    default_runner_type: RunnerType;
+    default_model: ModelConfig;
+}
 export interface CreateSkillParameterRequest {
     name: string;
     default_value?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "newo",
-  "version": "3.7.1",
+  "version": "3.7.2",
   "description": "NEWO CLI: Professional command-line tool with modular architecture for NEWO AI Agent development. Features account migration, integration management, webhook automation, AKB knowledge base, project attributes, sandbox testing, IDN-based file management, real-time progress tracking, intelligent sync operations, and comprehensive multi-customer support.",
   "type": "module",
   "bin": {

package/src/api.ts

@@ -23,8 +23,11 @@ import type {
   CreateSkillResponse,
   CreateFlowEventRequest,
   CreateFlowEventResponse,
+  UpdateFlowEventRequest,
   CreateFlowStateRequest,
   CreateFlowStateResponse,
+  UpdateFlowStateRequest,
+  UpdateFlowRequest,
   CreateSkillParameterRequest,
   CreateSkillParameterResponse,
   CreateCustomerAttributeRequest,
@@ -151,6 +154,30 @@ export async function listFlowSkills(client: AxiosInstance, flowId: string): Pro
   return response.data;
 }
 
+/**
+ * Fetch a single flow's top-level descriptor.
+ *
+ * Used by push to detect whether local metadata.yaml title/description
+ * differ from the platform before patching.
+ */
+export interface FlowDescriptor {
+  id: string;
+  idn: string;
+  title: string;
+  description: string | null;
+  agent_id: string;
+  default_runner_type: string;
+  default_model: { provider_idn: string; model_idn: string };
+  publication_datetime?: string;
+  last_change_datetime?: string;
+  creation_datetime?: string;
+}
+
+export async function getFlow(client: AxiosInstance, flowId: string): Promise<FlowDescriptor> {
+  const response = await client.get<FlowDescriptor>(`/api/v1/designer/flows/${flowId}`);
+  return response.data;
+}
+
 export async function getSkill(client: AxiosInstance, skillId: string): Promise<Skill> {
   const response = await client.get<Skill>(`/api/v1/designer/skills/${skillId}`);
   return response.data;
@@ -345,6 +372,14 @@ export async function createFlowEvent(client: AxiosInstance, flowId: string, eve
   return response.data;
 }
 
+export async function updateFlowEvent(
+  client: AxiosInstance,
+  eventId: string,
+  eventData: UpdateFlowEventRequest
+): Promise<void> {
+  await client.patch(`/api/v1/designer/flows/events/${eventId}`, eventData);
+}
+
 export async function deleteFlowEvent(client: AxiosInstance, eventId: string): Promise<void> {
   await client.delete(`/api/v1/designer/flows/events/${eventId}`);
 }
@@ -354,6 +389,32 @@ export async function createFlowState(client: AxiosInstance, flowId: string, sta
   return response.data;
 }
 
+export async function updateFlowState(
+  client: AxiosInstance,
+  stateId: string,
+  stateData: UpdateFlowStateRequest
+): Promise<void> {
+  await client.put(`/api/v1/designer/flows/states/${stateId}`, stateData);
+}
+
+export async function deleteFlowState(client: AxiosInstance, stateId: string): Promise<void> {
+  await client.delete(`/api/v1/designer/flows/states/${stateId}`);
+}
+
+/**
+ * Update flow metadata (title, description, runner type, default model).
+ *
+ * Uses PATCH /api/v1/designer/flows/{flowId}. The platform requires the
+ * full flow descriptor; sending a partial body returns 500.
+ */
+export async function updateFlow(
+  client: AxiosInstance,
+  flowId: string,
+  flowData: UpdateFlowRequest
+): Promise<void> {
+  await client.patch(`/api/v1/designer/flows/${flowId}`, flowData);
+}
+
 export async function createSkillParameter(client: AxiosInstance, skillId: string, paramData: CreateSkillParameterRequest): Promise<CreateSkillParameterResponse> {
   // Debug the parameter creation request
   console.log('Creating parameter for skill:', skillId);

package/src/domain/strategies/sync/ProjectSyncStrategy.ts

@@ -49,7 +49,14 @@ import {
   publishFlow,
   listLibraries,
   updateLibrarySkill,
+  getFlow,
 } from '../../../api.js';
+import {
+  syncFlowMetadata,
+  emptyFlowSyncCounts,
+  totalFlowSyncOps,
+  describeFlowSyncCounts
+} from '../../../sync/flow-metadata.js';
 import {
   ensureState,
   writeFileSafe,
@@ -540,6 +547,24 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     for (const change of changes) {
       try {
         if (change.operation === 'modified') {
+          // Flow-level metadata.yaml needs different handling than a skill
+          // script: we sync title/events/state_fields rather than uploading a
+          // file. Detected by filename. (GH issue #3)
+          if (change.path.endsWith('/metadata.yaml') && !change.path.includes('/libraries/')) {
+            const pathParts = change.path.split('/');
+            // {customer}/projects/{project}/{agent}/{flow}/metadata.yaml
+            // Last 5 segments end with metadata.yaml; skip if it's a skill
+            // metadata file (one extra segment) - skill metadata is handled
+            // by V1 legacy push, not by this strategy yet.
+            const tail = pathParts.slice(-5);
+            const isFlowMeta = tail[0] === 'projects' || tail[2] && tail[4] === 'metadata.yaml';
+            if (isFlowMeta && tail.length === 5) {
+              const updateResult = await this.pushFlowMetadataUpdate(client, change, mapData, newHashes);
+              result.updated += updateResult;
+              continue;
+            }
+          }
+
           const isLibrary = change.path.includes('/libraries/');
           if (isLibrary) {
             const updateResult = await this.pushLibrarySkillUpdate(client, change, mapData, newHashes);
@@ -568,6 +593,64 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     return result;
   }
 
+  /**
+   * Push a flow metadata.yaml change — syncs title, events, and state_fields
+   * to the platform. Closes GH issue #3 (events/title silently un-synced).
+   *
+   * Path shape: newo_customers/{customer}/projects/{project}/{agent}/{flow}/metadata.yaml
+   */
+  private async pushFlowMetadataUpdate(
+    client: AxiosInstance,
+    change: ChangeItem<LocalProjectData>,
+    mapData: ProjectMap,
+    newHashes: HashStore
+  ): Promise<number> {
+    const pathParts = change.path.split('/');
+    // Tail: projects/{project}/{agent}/{flow}/metadata.yaml
+    const flowIdn = pathParts[pathParts.length - 2] || '';
+    const agentIdn = pathParts[pathParts.length - 3] || '';
+    const projectIdn = pathParts[pathParts.length - 4] || '';
+
+    const projectData = mapData.projects[projectIdn];
+    const agentData = projectData?.agents[agentIdn];
+    const flowData = agentData?.flows[flowIdn];
+
+    if (!flowData?.id) {
+      this.logger.warn(`Flow metadata change but flow not in project map: ${projectIdn}/${agentIdn}/${flowIdn}`);
+      return 0;
+    }
+
+    const content = await fs.readFile(change.path, 'utf8');
+    let localFlow: FlowMetadata;
+    try {
+      localFlow = yaml.load(content) as FlowMetadata;
+    } catch (error) {
+      throw new Error(`Failed to parse ${change.path}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+
+    let remoteFlow = null;
+    try {
+      remoteFlow = await getFlow(client, flowData.id);
+    } catch (error: any) {
+      this.logger.verbose(`Could not GET flow ${flowIdn}: ${error.response?.status ?? error.message}`);
+    }
+
+    const counts = emptyFlowSyncCounts();
+    await syncFlowMetadata(client, flowData.id, localFlow, remoteFlow, false, counts);
+
+    const total = totalFlowSyncOps(counts);
+    if (total > 0) {
+      this.logger.info(`↑ Flow ${flowIdn}: ${describeFlowSyncCounts(counts)}`);
+    }
+    for (const err of counts.errors) {
+      this.logger.warn(err);
+    }
+
+    // Stamp the hash so the next push skips this file unless it changes again.
+    newHashes[change.path] = sha256(content);
+    return total;
+  }
+
   /**
    * Push a skill update
    */
@@ -709,6 +792,23 @@ export class ProjectSyncStrategy implements ISyncStrategy<ProjectMeta, LocalProj
     for (const [projectIdn, projectData] of Object.entries(mapData.projects)) {
       for (const [agentIdn, agentData] of Object.entries(projectData.agents)) {
         for (const [flowIdn, flowData] of Object.entries(agentData.flows)) {
+          // Flow metadata change detection (title/events/state_fields).
+          // Surfaced as a change so push() picks it up alongside skill edits.
+          const flowMetaPath = flowMetadataPath(customer.idn, projectIdn, agentIdn, flowIdn);
+          if (await fs.pathExists(flowMetaPath)) {
+            const content = await fs.readFile(flowMetaPath, 'utf8');
+            const currentHash = sha256(content);
+            const storedHash = hashes[flowMetaPath];
+
+            if (storedHash !== currentHash) {
+              changes.push({
+                item: {} as LocalProjectData,
+                operation: 'modified',
+                path: flowMetaPath
+              });
+            }
+          }
+
           for (const [skillIdn, _skillData] of Object.entries(flowData.skills)) {
             const skillFile = await getSingleSkillFile(customer.idn, projectIdn, agentIdn, flowIdn, skillIdn);